【Java基础】- for 循环，foreach()

list 遍历的4中方式

1. 集合通用遍历方式,迭代器

        // 1. 集合通用遍历方式,迭代器
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

2. 集合通用的变量方式，迭代器

        // 2. 集合通用的变量方式，迭代器
        for (Iterator<String> it2 = list.iterator(); it2.hasNext(); ) {
            System.out.println(it2.next());
        }

3. 增强for循环遍历

        // 3. 增强for循环遍历
        for (String str : list) {
            System.out.println(str);
        }

4. 普通for循环

        // 4. 普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

5. 加强版for循环

        // 5. 加强版for 循环
        for (int i = 0, len = list.size(); i < len; i++) {
            System.out.println(list.get(i));
        }

遍历删除元素

1. 增强for循环遍历并删除 错误

        // 增强 for 循环遍历并删除 // 错误
        // 报异常  java.util.ConcurrentModificationException
        for (String str : list) {
            if (str.equals("python")) {
                list.remove(str);
            }
        }

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
    at java.util.ArrayList$Itr.next(ArrayList.java:859)
    at com.example.eureka.MainDemo3.main(MainDemo3.java:49)

增强for 循环内部是依赖Iterator 迭代器实现的遍历，迭代器依赖于集合，集合发生改变，迭代器没有及时改变，故发生异常。

2. 迭代器遍历，迭代器删除

        // 2. 迭代器遍历，迭代器删除
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            if ("python".equals(iterator.next())) {
                iterator.remove();
            }
        }

3.使用高级for循环遍历删除/增加元素时，如果在某次循环的过程中进行了删除或者是增加元素的操作，使用break或者return语句结束了循环操作，不报异常

        // 3.使用高级for循环遍历删除/增加元素时，如果在某次循环的过程中进行了删除或者是增加元素的操作，使用break或者return语句结束了循环操作，不报异常
        for (String str : list) {
            if (str.equals("python")) {
                list.remove(str);
                break;
            }
            System.out.println(str);
        }

4. 普通for循环删除，记得减角标

        // 4. 普通for循环删除
        // 忘记减角标 会出现问题 --i
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            if("python".equals(str)){
                list.remove(i);
                --i;  //  注意一定 角标减一
                continue;
            }
            System.out.println(str);
        }

效率对比

public class Student {

    private String name;

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

        // 添加100万条数据
        List<Student> integerList = new ArrayList<>();
        for (int i = 0; i < 1000000; i++) {
            integerList.add(new Student(String.valueOf(i)));
        }

        // 普通for循环
        long start = System.currentTimeMillis();
        Student student;
        for (int i = 0, len = integerList.size(); i < len; i++) {
            student = integerList.get(i);
        }
        System.out.println();
        System.out.println("普通for循环 time: " + (System.currentTimeMillis() - start)+"ms");

        // 迭代器
        long start2 = System.currentTimeMillis();
        for (Iterator<Student> iterator = integerList.iterator(); iterator.hasNext(); ) {
            student = iterator.next();
        }
        System.out.println();
        System.out.println("迭代器 time: " + (System.currentTimeMillis() - start2)+"ms");

        // 增强for循环
        long start3 = System.currentTimeMillis();
        for (Student i : integerList) {
            student = i;
        }
        System.out.println();
        System.out.println("增强for循环 time: " + (System.currentTimeMillis() - start3)+"ms");

测试结果：

普通for循环 time: 7ms

迭代器 time: 9ms

增强for循环 time: 8ms