JavaSE基础部分--增强for循环

增强for循环

（1）增强for循环概述

增强 for循环 JDK1.5 引入的语法，简化数组和Collection集合的遍历

（2）格式：

for(元素数据类型 变量 : 数组或者Collection集合) {

使用变量即可，该变量就是元素

}

（3）好处和注意事项

好处：简化遍历

注意事项：增强for的目标要判断是否为null

注意新式for循环，你在迭代集合的途中，不能增删元素，会报并发修改异常

public class MyTest {
    public static void main(String[] args) {
        int[] arr={20,30,50};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("================================");
        for(int a:arr){
            System.out.println(a);
        }
        System.out.println("==============================");
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
        integers.add(200);
        integers.add(300);
        integers.add(400);
        for(Integer num:integers){
            System.out.println(num);
        }
    }
}
注意事项  并发修改异常
public class MyTest2 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
        integers.add(200);
        integers.add(300);
        integers.add(400);
        
        //ConcurrentModificationException 并发修改异常
        //新式for循环在遍历集合时，底层用的还是迭代器，你在遍历途中，如果改变集合的长度，就会报并发修改异常。
      /*  for (Integer integer : integers) {
            if(integer.intValue()==200){
                integers.add(300);
            }
        }
*/
		//解决办法
        for (int i = 0; i < integers.size(); i++) {
            if (integers.get(i).intValue()==200) {
                integers.add(300);
            }
        }

        System.out.println(integers);

    }
}

可变参数

（1）可变参数概述:

定义方法的时候不知道该定义多少个参数

（2）格式:

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

（3）注意事项：

a: 这里的变量其实是一个数组

b: 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

public class MyTest {
    public static void main(String[] args) {
        int sum = add(1, 2);
        int sum2 = add(1, 2, 3);
        int sum3 = add(1, 2, 3, 4);

        System.out.println(sum);
        System.out.println(sum2);
        System.out.println(sum3);

    }
    //可变参数，一次可以接收多个同类型的参数
    //可变参数 本质是是个数组
    //如果一个方法的形参有多个参数，那么可变参数，应该是最后一个。
    private static int add(int b,int... a) {
        //System.out.println(a.length);
        int sum=b;
        for (int i : a) {
            sum += i;
        }
        return sum;
    }
    //如果不采用可变参数，需要方法重载 代码量大 复用性不高，如下，

   /* private static int add(int i, int i1, int i2, int i3) {
        return i1 + i2 + i3 + i;
    }

    private static int add(int i, int i1, int i2) {
        return i1 + i2 + i;
    }

    private static int add(int i, int i1) {
        return i1  + i;

    }*/

}

Arrays工具类的asList()方法的使用

Arrays工具类的asList(T… t)：将数组转换成集合

（1）如果传的是一个基本类型的数组，他是把这个数组对象，放到集合中。

（2）如果传入的是一个包装类型的数组，他是吧数组中的元素，取出来放到集合中。

（3）如果传入多个包装类型的数组，那么他是把多个数组对象，放到集合中。

注意事项：

得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)

只能获取元素(get)

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr={20,30,40};
        //我传的是一个基本类型的数组，他是把这个数组对象，放到集合中
        List<int[]> ints = Arrays.asList(arr);
        System.out.println(ints.size());//1
        System.out.println(ints.get(0)[0]);//20
        
        Integer[] arr2 = {20, 30, 40};
        //我传入的是一个包装类型的数组，他是吧数组中的元素，取出来放到集合中
        List<Integer> integers = Arrays.asList(arr2);
        System.out.println(integers.size());//3
        System.out.println(integers);//[20, 30, 40]
        Integer[] arr3 = {20, 30, 40};
        Integer[] arr4 = {20, 30, 400};
        //如果你传入多个包装类型的数组，那么他是把多个数组对象，放到集合中。
        List<Integer[]> integers1 = Arrays.asList(arr3, arr4);
        System.out.println(integers1.size());//2
        Integer integer = integers1.get(1)[2];
        System.out.println(integer);//400
        //也可以这样得到一个集合。
        List<Integer> integers2 = Arrays.asList(20, 20, 30, 50, 30);
        System.out.println(integers2.size());//5
        System.out.println(integers2);//[20, 20, 30, 50, 30]
    }
}

集合嵌套之ArrayList嵌套ArrayList

代码举例
需求：

我们班有学生，每一个学生是不是一个对象，所以我们可以使用一个集合表示我们班级的学生

ArrayList但是呢，我们是不是还有班级，每个班级是不是也是一个ArrayList

而我现在有多个ArrayList。也要用集合存储，怎么办呢 ?

采用集合嵌套：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +

                '}';
    }
}
public class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 23);
        Student s3 = new Student("王五", 23);
        Student s4 = new Student("赵六", 23);
        Student s5 = new Student("田七", 23);
        Student s6 = new Student("刘八", 23);
        ArrayList<Student> javaList = new ArrayList<>();
        javaList.add(s1);
        javaList.add(s2);
        ArrayList<Student> webList = new ArrayList<>();
        webList.add(s3);
        webList.add(s4);
        ArrayList<Student> linuxList = new ArrayList<>();
        linuxList.add(s5);
        linuxList.add(s6);
        ArrayList<ArrayList<Student>> maxList = new ArrayList<>();
        maxList.add(javaList);
        maxList.add(webList);
        maxList.add(linuxList);
        //遍历集合中的每一个学生。
        //普通for循环
        //外层循环  ArrayList<ArrayList<Student>> maxList = new ArrayList<>() 对这个集合进行操作
        for (int i = 0; i < maxList.size(); i++) {
            
            ArrayList<Student> minList = maxList.get(i);
            //里层循环对ArrayList<Student> javaList = new ArrayList<>() 类集合进行操作
            for (int j = 0; j < minList.size(); j++) {
                Student student = minList.get(j);
                System.out.println(student.getName()+"==="+student.getAge());
            }
            System.out.println();
        }
        System.out.println("==================================");
        //增强for循环 遍历学生
      /*  for (ArrayList<Student> minList : maxList) {
            for (Student student : minList) {
                System.out.println(student.getName() + "===" + student.getAge());
            }
            System.out.println();
        }
        System.out.println("================================");*/
    }
}