2021-09-02

集合框架

数组，集合都是对多个数据进行存储操作的，简称为容器。

PS：这里的存储指的是内存层面的存储，而不是持久化存储(.txt, .avi, .jpg)
数组的特点：

1. 数组一旦指定了长度，那么长度就被确定了，不可以更改.
   int[] arr = new int[6];

2. 数组一旦声明了类型之后，数组只能存放这个类型的数据，数组中只能存放同一种类型地数据
   int[] arr, String[] s, double[] d…

3. 数组地缺点：

   (1) 数组一旦指定了长度就被确定了，不可以更改。

（2) 删除，增加元素，效率低。

(3)  数组中实际元素的数量是没有办法获取的，没有提供对应的方法或属性来获取。
(4)   数组存储：有序，可重复，对于无序的，不可重复的数组不能满足要求。

4. 正因为上面的缺点，引入了一个·新的存储数据的结构 --》集合

ArrayList实现类和Vector实现类

联系：底层都是数组扩容

区别：

ArrayList底层扩容长度为原数组的1.5倍，线程不安全，效率高

Vector底层扩容长度为原数组地2倍 线程安全 效率低下 （淘汰）

泛型

1. 在JDK1.5之后才存在地
2. 泛型实际上就是一个<>引起来地参数类型，这个参数类型 具体在使用的时候才会确定具体的类型
3. 使用范型以后，可以确定集合中存放的数据类型，在编译时期就可以检测出来
4. 使用泛型以后，你可能觉的麻烦，实际使用泛型才会简单，后续的遍历等操作简单
5. 泛型的数据类型都是引用数据类型，不是基本数据类型
6. ArrayList al = new ArrayList() 在JDK1.7以后可以写为：ArrayList al = new ArrayList<>();
   

public class GemTest<E> {
    int age;
    String name;
    E sex;

    public void a(E n) {

    }

    public void b(E[] m) {

    }
}
//不指定泛型
class SubGemTest extends GemTest<Integer>{

}
//指定泛型
class SubGemTest2<E> extends GemTest<E>{

}
class Demo2{
    public static void main(String[] args) {
        SubGemTest2<String> sgt2 = new SubGemTest2<>();
        sgt2.a("abc");
        sgt2.sex = "女";

    }
}
class Demo{
    public static void main(String[] args) {
        SubGemTest sgt = new SubGemTest();
        sgt.a(13);

    }
}

class Test{
    public static void main(String[] args) {
        GemTest gt1 = new GemTest();
        gt1.a(12);
        gt1.a(3.4);
        gt1.a("lou");
        gt1.b(new String[]{"杂货","参数" ,"删除","上传"});
        gt1.b(new Integer[]{1,3,54,65,67});
        gt1.b(new Double[]{1.32,13.3,123.4,12324.566});

        GemTest<String> gt2 = new GemTest<>();
        gt2.sex = "Tom";
        gt2.a("狸猫");
        gt2.b(new String[]{"杂货","参数" ,"删除","上传"});
        /*gt2.b(new Integer[]{1,3,54,65,67});
        gt2.b(new Double[]{1.32,13.3,123.4,12324.566});*/


    }
}

import java.util.ArrayList;
import java.util.List;

public class GemTest_03 {
    /*public void a(List<Object> list){

    }
    public void a(List<String> list){

    }
    public void a(List<int> list){

    }*/
    public void a(List<?> list){
//        遍历使用Object,不适用?
//        遍历
        for (Object o : list) {
            System.out.println(o);
        }
//        list.add(112);不能随意的添加数据,处理null
        list.add(null);
//        可以进行读取
        list.get(3);

    }
    public static void main(String[] args) {
        List<Object> ls1 = new ArrayList<>();
        List<String> ls2 = new ArrayList<>();
        List<Integer> ls3 = new ArrayList<>();
//       使用通配符? G<?>成为了G<Integer>,G<String>的父类
        List<?> list = null;
        list = ls1;
        list = ls2;
        list = ls3;

        GemTest_03 t = new GemTest_03();
        t.a(new ArrayList<Object>());
        t.a(new ArrayList<String>());
        t.a(new ArrayList<Integer>());

    }
}

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<Object> a = new ArrayList<>();
        List<Person> b = new ArrayList<>();
        List<Student> c = new ArrayList<>();
        /*
        开始使用泛型的受限；泛型的上限，往下取
        List<? extends Person>
        就相当于
        List<? extends Person>是List<Person>的父类，也是list<Person子类>的父类

         */

        List<? extends Person> list1 = null;
        /*list = a;*/
        list1 = b;
        list1 = c;

//        泛型的下限,往上取
        /*
        开始使用泛型的受限；泛型的上限，往下取
       List<? super Person>
        就相当于
        List<? super Person>是List<Person>的父类，也是list<Person父类>的父类

         */

        List<? super Person> list2 = null;
        list2 = a;
        list2 = b;
        /*list2 = c;*/
    }
}