🍬 博主介绍
👨🎓 博主介绍：大家好，我是 hacker-routing ，很高兴认识大家~
✨主攻领域：【渗透领域】【应急响应】 【Java】 【VulnHub靶场复现】【面试分析】
🎉点赞➕评论➕收藏 == 养成习惯（一键三连）😋
🎉欢迎关注💗一起学习👍一起讨论⭐️一起进步📝文末有彩蛋
🙏作者水平有限，欢迎各位大佬指点，相互学习进步！
目录
LinkedList和迭代器的源码分析
ArraList集合底层原理
-
利用空参创建的集合，在底层创建一个默认长度为0的数组
-
添加第一个元素时，底层会创建一个新的长度为10的数组
-
存满时，会扩容1.5倍
-
如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准
LinkedList集合
- 底层数据结构是双链表，查询慢，增删快，但是如果操作的是首尾元素，速度也是极快的。
- LinkedList本身多了很多直接操作首尾元素的特有API。
LinkedList底层源码分析
泛型类、泛型方法、泛型接口
泛型深入
泛型：是jdk5中引入的特性，可以在编译阶段约束的数据类型，并进行检查。
泛型的格式：<数类型>
注意：泛型只能支持引用数据类型
不使用泛型，无法使用前面的特有行为
package list;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Objects;
public class generics {
public static void main(String[] args) {
//没有泛型的时候，集合如何存储数据
//结论：
//如果我们没有给集合指定类型，默认认为所有的数据类型都是Object类型
//此时可以往集合添加任意的数据类型。
//带来一个坏处：我们在获取数据的时候，无法使用他的特有行为。
//此时推出了泛型，可以在添加数据的时候就把类型进行统一。
//而且我们在获取数据的时候，也省的强转了，非常的方便。
//1、创建集合的对象
ArrayList list = new ArrayList();
//2、添加数据
list.add(123);
list.add("aaa");
list.add(new student("zhangsan",21));
//3、遍历集合获取里面的每一个元素
Iterator it = list.iterator();
while (it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}
}
使用泛型：
package list;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Objects;
public class generics {
public static void main(String[] args) {
//没有泛型的时候，集合如何存储数据
//结论：
//如果我们没有给集合指定类型，默认认为所有的数据类型都是Object类型
//此时可以往集合添加任意的数据类型。
//带来一个坏处：我们在获取数据的时候，无法使用他的特有行为。
//此时推出了泛型，可以在添加数据的时候就把类型进行统一。
//而且我们在获取数据的时候，也省的强转了，非常的方便。
//1、创建集合的对象
ArrayList<String> list = new ArrayList<>();
//2、添加数据
list.add("aaa");
//3、遍历集合获取里面的每一个元素
Iterator<String> it = list.iterator();
while (it.hasNext()){
String str = it.next();
//多态的弊端是不能访问子类的特有功能
System.out.println(str);
}
}
}
泛型的好处及拓展
统一数据类型。
把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来。
泛型的细节
-
泛型中不能写基本数据类型
-
指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型
-
如果不写泛型，类型默认是Object
1、泛型类
代码演示：
package list;
import java.util.Arrays;
import java.util.Objects;
public class myarraylist<E> {
Object[] obj = new Object[10];
int size;
/*
E : 表示是不确定的类型。该类型在类名后面已经定义过了。
e：形参的名字，变量名
* */
public boolean add(E e){
obj[size] = e;
size++;
return true;
}
public E get(int index){
return (E)obj[index];
}
@Override
public String toString() {
return Arrays.toString(obj);
}
}
package list;
public class GenericsDemo2 {
public static void main(String[] args) {
/* MyArrayList<String> list = new MyArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
System.out.println(list);*/
myarraylist<Integer> list2 = new myarraylist<>();
list2.add(123);
list2.add(456);
list2.add(789);
int i = list2.get(0);
System.out.println(i);
System.out.println(list2);
}
}
2、泛型方法
练习 泛型方法的练习
定义一个工具类：listutil
类中定义一个静态的方法addAll，用来添加多个集合的元素。
listutil类：
package list;
import java.util.ArrayList;
public class listutil {
private listutil(){}
public static<E> void addAll(ArrayList<E> list, E e1, E e2, E e3, E e4){
list.add(e1);
list.add(e2);
list.add(e3);
list.add(e4);
}
public void show(){
System.out.println("hello world!!!");
}
}
GenericsDemo3类：
package list;
import java.util.ArrayList;
//定义一个工具类：listutil
//类中定义一个静态方法addall，用来添加多个集合的元素
public class GenericsDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
listutil.addAll(list,"aaa","bbb","ccc","ddd");
System.out.println(list);
}
}
3、泛型接口
定义一个myarraylist2类
package list;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class myarraylist2 implements List<String> {
@Override
public int size() {
return 0;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean contains(Object o) {
return false;
}
@Override
public Iterator<String> iterator() {
return null;
}
@Override
public Object[] toArray() {
return new Object[0];
}
@Override
public <T> T[] toArray(T[] a) {
return null;
}
@Override
public boolean add(String s) {
return false;
}
@Override
public boolean remove(Object o) {
return false;
}
@Override
public boolean containsAll(Collection<?> c) {
return false;
}
@Override
public boolean addAll(Collection<? extends String> c) {
return false;
}
@Override
public boolean addAll(int index, Collection<? extends String> c) {
return false;
}
@Override
public boolean removeAll(Collection<?> c) {
return false;
}
@Override
public boolean retainAll(Collection<?> c) {
return false;
}
@Override
public void clear() {
}
@Override
public String get(int index) {
return null;
}
@Override
public String set(int index, String element) {
return null;
}
@Override
public void add(int index, String element) {
}
@Override
public String remove(int index) {
return null;
}
@Override
public int indexOf(Object o) {
return 0;
}
@Override
public int lastIndexOf(Object o) {
return 0;
}
@Override
public ListIterator<String> listIterator() {
return null;
}
@Override
public ListIterator<String> listIterator(int index) {
return null;
}
@Override
public List<String> subList(int fromIndex, int toIndex) {
return null;
}
}
GenericsDemo4类：
package list;
public class GenericsDemo4 {
public static void main(String[] args) {
/*
泛型接口的两种使用方式：
1.实现类给出具体的类型
2.实现类延续泛型，创建实现类对象时再确定类型
*/
//1、实现类给出具体的类型
// myarraylist2<String> list = new myarraylist2<>();
//2、实现类延续泛型，创建实现类对象时再确定类型
myarraylist2 list = new myarraylist2();
list.add("123");
System.out.println(list);
}
}
