List的三大子类以及泛型_list 的泛型是子类

List的三大子类以及泛型，可变参数

1.List的三大子类是什么,有什么特点?

• ArrayList

Array底层的数据结构为数组，随机增删慢，查询效率高

ArrayList的初始化容量为10，每次扩容为上次的1.5倍

非线程安全的，也就是不是线程同步

private static final int DEFAULT_CAPACITY = 10;

 int oldCapacity = elementData.length;
 int newCapacity = oldCapacity + (oldCapacity >> 1);
 //以上代码均来源于源码
1
2
3
4
5

• LinkedList

LinkedList底层为链表，查询效率低，但随机增删效率高

链表的初始化容量为0，每次扩容加1

transient int size = 0;
1

• Vector

Vector底层为数组，查询效率高，随机增删效率低

线程安全的

数组容量

//构造函数矢量队列初始化大小和增长大小
public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);                                  
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
//构造函数初始化大小
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
//构造函数默认初始化大小为10
   public Vector() {
        this(10);
    }	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.泛型机制

• 什么是泛型?

是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型

• 泛型优点

1.将运行时期的问题提前到了编译期间

2.避免了强制类型转换

3.泛型只在编译期间有效，在运行期就擦除了

public class Demo1 {
    public static void main(String[] args) {
        //没使用泛型机制
       ArrayList arrayList=new ArrayList();
       arrayList.add(100);
       arrayList.add(200);
       arrayList.add(300);
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            Integer integer=(Integer)next;
        }
        System.out.println("=================");
        //使用泛型机制
        ArrayList<String> arrayList1=new ArrayList<>();
        arrayList1.add("100");
        arrayList1.add("200");
        arrayList1.add("300");
        Iterator<String> iterator1 = arrayList1.iterator();
        while (iterator1.hasNext()){
            String next = iterator1.next();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• 泛型类

public class Student<T,E> {
private T name;
private E age;
}
1
2
3
4

• 泛型方法

public class Demo2 {
    public static void main(String[] args) {
        getName("ls");
        getName(520);
        getName('u');
        Demo2 demo2=new Demo2();
        demo2.getNum("1000");
        demo2.getNum(100);
    }
    //静态泛型
    public static<T>  void getName(T name){
        System.out.println(name);
    }
    //非静态泛型
    public<E> void getNum(E num){
        System.out.println(num);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 泛型接口

//泛型接口
public interface MyInterface<T> {
    public abstract void getNum(T name);
}
//子类实现泛型接口
public class MyInterfaceText implements MyInterface<String>{
    public static void main(String[] args) {

    }
    @Override
    public void getNum(String name) {

    }
}
//匿名内部类
public class MyInterfaceText1 {
    public static void main(String[] args) {
      new MyInterface<Integer>(){
          @Override
          public void getNum(Integer name) {
              
          }
      };
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• 泛型通配符

泛型通配符<?>:		任意类型，如果没有明确，那么就是Object以及任意的Java类
? extends E:	    向上限定，E及其子类
? super E:			向下限定，E及其父类
1
2
3

public class Demo3 {
    public static void main(String[] args) {
        //  ?匹配一切引用类型
        ArrayList<?> arrayList=new ArrayList<Object>();
        ArrayList<?> arrayList1=new ArrayList<String>();
        ArrayList<?> arrayList2=new ArrayList<Integer>();

        // ? extends E 向上限定，?只能为 E的子类和E本身
        ArrayList<? extends Date> arrayList3=new ArrayList<Date>();
        ArrayList<? extends Date> arrayList4=new ArrayList<java.sql.Date>();

        // ? super E 向下限定，?只能为E本身和E 的父类
        ArrayList<? super ArrayList> arrayList5=new ArrayList<ArrayList>();
        ArrayList<? super  ArrayList> arrayList6=new ArrayList<List>();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.可变参数

• 什么是可变参数?

当个数不确定时，使用可变参数，可变参数可以是0个，也可以是无数个。

• 格式

修饰符 返回值类型 方法名(数据类型…  变量名){}
1

• 注意事项

可变参数可以存储数组，可变参数实际来说就是一个数组

一个方法有且只能有一个可变参数，且必须在最后位置。

public class Demo4 {

    public static void main(String[] args) {
        getSum(2,4,3);
        getNum(1,2,3,4);
    }
    //求n个数的乘积,,n为任何数
    public static void getSum(int...num){
        int sum=1;
        for (int data:
             num) {
          sum*=data;
        }
        System.out.println(sum);
    }
    //求n个数和a的和
    public static void getNum(int a,int...num){
        int b=a;
        for (int data:
                num) {
            b+=data;
        }
        System.out.println(b);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25