Collection-泛型

1、泛型的由来

通过Object转型问题引入泛型：早期的Object类型可以接受任意的对象类型，但是在实际使用过程中，会出现类型转换的问题。所以就引入了泛型来解决这个安全问题。

2、泛型的概述和基本使用

1. 泛型概述
   JDK1.5引入的泛型机制，是一种将数据类型明确工作推迟到创建对象或调用方法时才去明确的特殊的类型。
2. 泛型的格式
   泛型可以使用在类、接口、方法中。
   <数据类型> 这里的数据类型只能是引用类型
3. 泛型的好处
   （1）把运行时期的问题提前到了编译器
   （2）避免了强制类型转换（向下转型）
   （3）优化了程序设计，解决了黄色警告线

3、泛型类的概述及使用

1. 泛型类的概述
   把泛型定义在类上
2. 定义格式
   public class 类名<泛型类型1,…>，泛型类型必须是引用类型
3. 案例演示：

public class MyTest {
    public static void main(String[] args) {
        MyClass<Integer> integerMyClass = new MyClass<>();//通过泛型明确数据类型为Integer
        integerMyClass.setObj(200);
        Integer obj = integerMyClass.getObj();//直接返回Integer类型
        System.out.println(obj);//200
    }
}

public class MyClass<T> {
        private T obj;

    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}

4、泛型方法的概述及使用

1. 泛型方法的概述
   把泛型定义在方法上
2. 定义格式
   public <泛型类型> 返回类型 方法名 （泛型类型 变量名）

5、泛型接口的概述及使用

1. 泛型接口的概述
   把泛型定义在接口上
2. 定义格式
   public interface 接口名 <泛型类型>

6、泛型高级之通配符

1. 泛型通配符：

<?> 任意类型，如果没有明确，距代表Object或任意的java类

2. 向下限定:<? extends E>。 向下限定，? 表示的是：E及其子类。
3. 向上限定:<? super E>。 向上限定，? 表示的是：E及其父类。

7、增强for循环的概述及使用

简化了数组和集合的遍历。

• 格式：

 for（元素的数据类型 变量 ： 数组或者集合的名称）{
     使用变量即可，改变量就是元素
 }

• 案例演示：

public class MyTest3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        for (int ele: arr){
            System.out.println(ele);
        }
    }
}

• 普通for循环和增强for循环的区别：
  1、当要使用元素的索引进行判断时，应该使用普通的for循环。
  2、如果只是为了遍历容器中的元素，就使用增强for循环。
  3、增强for循环底层是使用迭代器在迭代。所以在使用增强for循环时，不能进行增删，否则会出现并发修改异常。

8、可变参数的概述及使用

1. 可变参数的概述：
   定义方法的时候不知道该定义多少个参数
2. 格式：

 修饰符 返回值类型 方法名（数据类型... 变量名）{}

3. 注意事项
   a：这里的变量其实是一个数组
   b：如果一个方法有可变参数，并且有多个参数，那可变参数肯定是最后一个

public class MyTest4 {
    public static void main(String[] args) {
        int sum1 = add(2, 3);
        int sum2 = add(2, 4, 6);
        int sum3 = add(2, 4, 6,8);
        System.out.println(sum1);//5
        System.out.println(sum2);//12
        System.out.println(sum3);//20
    }
    public static int add(int... num){
        int sum =0;
        for (int i = 0; i < num.length; i++) {
            sum+=num[i];
        }
        return sum;
    }
}

9、Arrays工具类的asList()方法

static List asList(T… a)
返回一个受指定数组支持的固定大小的列表。 也就是将数组转换为集合。

public class MyTest5 {
    public static void main(String[] args) {
        //static <T> List<T> asList(T... a)
        // 返回一个受指定数组支持的固定大小的列表。 就是将数组转换为集合
        Integer[] integers={10,20,30,40};
        //如果放入的是一个引用类型的数组，它会取出数组中的元素放入集合中
        List<Integer> integers1 = Arrays.asList(integers);
        System.out.println(integers1);//[10, 20, 30, 40]
        System.out.println("=============");
        Integer[] integers2={10,20,30,40};
        Integer[] integers3={10,20,30,40};
        //如果你放入的是两个引用类型的数组，它将数组对象作为元素放入集合中
        List<Integer[]> integers4 = Arrays.asList(integers2, integers3);
        System.out.println(integers4);//[[Ljava.lang.Integer;@1b6d3586, [Ljava.lang.Integer;@4554617c]
        System.out.println("=====================================");
        int[] ints={1,2,3,4};
        //如果放入的是一个基本类型的数组，它将数组对象作为元素放入集合中
        List<int[]> ints1 = Arrays.asList(ints);
        System.out.println(ints1);//[[I@74a14482]
        System.out.println("===========");
        int[] ints2={1,2,3,4};
        //如果放入的是两个基本类型的数组，它将数组对象作为元素放入集合中
        List<int[]> ints3 = Arrays.asList(ints, ints2);
        System.out.println(ints3);//[[I@74a14482, [I@1540e19d]
    }
}

注意事项

通过asList（）方法得到的集合长度是不可变的，不能往这个转换后的集合中添加和删除元素，只能获取和修改元素。

10、集合嵌套-ArrayList嵌套ArrayList

public class MyTest {
    public static void main(String[] args) {
        ArrayList<Student> javaList = new ArrayList<>();
        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("李四", 20);
        Student stu3 = new Student("王五", 22);
        javaList.add(stu1);
        javaList.add(stu2);
        javaList.add(stu3);


        ArrayList<Student> webList = new ArrayList<>();
        Student stu4 = new Student("张三11", 18);
        Student stu5 = new Student("李四11", 20);
        Student stu6 = new Student("王五11", 22);
        webList.add(stu4);
        webList.add(stu5);
        webList.add(stu6);

        ArrayList<Student> cList = new ArrayList<>();
        Student stu7 = new Student("张三22", 18);
        Student stu8 = new Student("李四22", 20);
        Student stu9 = new Student("王五22", 22);
        cList.add(stu7);
        cList.add(stu8);
        cList.add(stu9);

        ArrayList<ArrayList<Student>> westosLists = new ArrayList<>();
        westosLists.add(javaList);
        westosLists.add(webList);
        westosLists.add(cList);
      /*  //遍历集合中的元素
        for (int i = 0; i < westosLists.size(); i++) {
            ArrayList<Student> minList = westosLists.get(i);
            for (int j = 0; j < minList.size(); j++) {
                Student student = minList.get(j);
                System.out.println(student.getName()+"=="+student.getAge());
            }
        }*/

        //使用增强for循环
        for (ArrayList<Student> students:westosLists){
            for (Student student:students){
                System.out.println(student.getName()+"=="+student.getAge());
            }
        }
    }
}