Java 泛型 和 集合的嵌套

一 泛型
泛型的好处：
1 增加了代码的安全性
2 省去了强制转换的麻烦（向下转换）
下面我们来俱下例子，看看泛型长什么样

ArrayList<String> list = new ArrayList<String>();

泛型 就是声明集合中保存的元素是什么类型的 可以看到 上面保存的元素是String类型的 后面的String也可省略

ArrayList<String> list = new ArrayList<>();

当后面不写时 默认和声明泛型一致

泛型接口
？ extends E
其中？是子类 E是父类
向下限定 只允许 子类 或者孙子类等

int…num 相当于一个数组
来看看int…num 的例子

public static void print1(int a ,int ... num) {
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }

    }

public static void fun2() {
        int[] array = new int[] {1,2,3,4,5,6};
        print1(3,array);
        print1(1,3,5,7,8,99,1000);
    }

String[] strings = {"wanglong","wangning"};
        List<String> asList = Arrays.asList(strings);

        ListIterator<String> listIterator = asList.listIterator();
        while (listIterator.hasNext()) {

            System.out.println(listIterator.next());

上面这段代码 不能添加和删除 有什么意义呢？

意义在于 可以使用集合中其他方法

删除的三种方法
即遍历的三种方法

1 普通遍历

ArrayList<String> strings = new ArrayList<>();
        strings.add("a");
        strings.add("b");
        strings.add("b");
        strings.add("c");
        strings.add("d");
        //  不使用迭代遍历
        //  如果集合中有b就删除它
        for (int i = 0; i < strings.size(); i++) {
            if (strings.get(i).equals("b")) {
                // i-- 标示,每次删除后都把角标回调一次
                strings.remove(i--);
            }

            System.out.println(strings.get(i));

        }
    }

二 迭代器遍历

ArrayList<String> strings = new ArrayList<>();
        strings.add("a");
        strings.add("b");
        strings.add("c");
        strings.add("d");
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            if (next.equals("b")) {
                //  让迭代器删除
                //  如果要添加元素 要用List中特有的迭代器  ListIterator 
                iterator.remove();
            }
        }   
        System.out.println(strings);

3 增强for循环遍历

ArrayList<String> strings = new ArrayList<>();
        strings.add("a");
        strings.add("b");
        strings.add("c");
        strings.add("d");
        //  遍历
        //  冒号后 是你要遍历的容器
        //  冒泡前 是你要遍历的同期中每一个元素
        //  增强for循环 底层是用 迭代器实现的
        //  一般志勇看来打印 不要做删除操作
        for (String string : strings) {

            System.out.println(string);

        }

二 集合的嵌套
需求: 一个java学科 有两个班 每个班里有两个学生
用集合来表示
学科中装了 两个小集合
每个小集合 装的是学生

ArrayList<ArrayList<Students>> subjects = new ArrayList<>();
        //  创建小集合
        ArrayList<Students> classes1 = new ArrayList<>();
        //  把学生装进小集合
        classes1.add(new Students("凉凉", 80));
        classes1.add(new Students("宁宁", 79));
        //  创建班2
        ArrayList<Students> classes2 = new ArrayList<>();
        classes1.add(new Students("星星", 73));
        classes1.add(new Students("涵涵", 84));
        //  把班放进学科
        subjects.add(classes1);
        subjects.add(classes2);
        //  遍历打印
        //  一层循环 把班找出来
        for (ArrayList<Students> classes : subjects) {
            //  二层循环 把班里学生找出来
            for (Students students : classes) {
                System.out.print(students);
            }
            System.out.println();
        }