java For的使用 、迭代器使用

package com.cskaoyan.common;


import org.junit.Test;

import java.util.ArrayList;

public class ForEachTest {


    @Test
    public void arrayTest1() {
        int[] ints = {1, 2, 3};
        //在for方法中，进行便利的时候会重新一个指定类型(int)的变量去接收等待遍历的每一个元素，
        //也就相当于它只能做遍历无法进行修改元素之类的工作
        for (int anInt : ints) {
            anInt += 1;
            System.out.println(anInt);
        }
        for (int anInt : ints) {
            System.out.println(anInt);
        }
    }

    @Test
    public void ListTest() {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(4);
        integers.add(5);

        /**
         * 对集合的遍历是通过拿到集合的迭代器，将迭代器的值赋值给一个同样类型的值（使用强转）。然后同样类型的这个值进行操作。
         */
        for (Integer integer : integers) {
            integer += 1;
        }
        System.out.println(integers);
    }
    /**
     * 总结：只要使用了for()而不是fori，生成的字节码实现逻辑就不会去修改这个遍历对象原有的值，而是把这个值用一个新的值去接收。
     * 然后对这个新的值进行操作。
     * 而集合和数组的不同在于，取原来集合中的值的方式的不同。
     * 数组采用的是fori的方式
     * 集合采用的是迭代器的方式
     * 但是两者最后都会用一个新的值去接受它。
     */


}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.cskaoyan.common;

import java.util.ArrayList;
import java.util.Iterator;
import org.junit.Test;

public class ForEachTest {
    public ForEachTest() {
    }

    @Test
    public void arrayTest1() {
        int[] ints = new int[]{1, 2, 3};
        int[] var2 = ints;
        int var3 = ints.length;

        int var4;
        int anInt;
        for(var4 = 0; var4 < var3; ++var4) {
            anInt = var2[var4];
            ++anInt;
            System.out.println(anInt);
        }

        var2 = ints;
        var3 = ints.length;

        for(var4 = 0; var4 < var3; ++var4) {
            anInt = var2[var4];
            System.out.println(anInt);
        }

    }

    @Test
    public void ListTest() {
        ArrayList<Integer> integers = new ArrayList();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(4);
        integers.add(5);

        Integer integer;
        for(Iterator var2 = integers.iterator(); var2.hasNext(); integer = integer + 1) {
            integer = (Integer)var2.next();
        }

        System.out.println(integers);
    }
}

迭代器主要就是一个线程安全的问题，因为迭代器为了本身的效率他是线程不安全的，因此设置了两个参数

modCount(目前为止这个集合被修改的次数--只会增加)：这个参数在集合创建完的时候值是数组的大小，因为需要添加元素。

expectedModCount:这个参数是“期望集合被修改的次数---本线程内集合被修改的次数”，只有这两个值相等的时候才不会报错。

本来是为了线程安全的，但是设计的原因，只要你不是通过迭代器操作的元素，那么就会导致这两个参数不一致从而导致抛出异常 ->线程并发安全异常

    public void iteratorTest() {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);

        Iterator<Integer> iterator = integers.iterator();
        while (iterator.hasNext()) {
            integers.add(3);
//因为上面增加了一个元素导致，modCount+1，而expectedModCount没有加一，在执行下面这一行代码的时候会报错
            System.out.println(iterator.next());
            iterator.remove();
        }
        System.out.println(integers);
    }


//报错的代码

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }