typescript array删除数组元素 arraylist foreach删除

ArrayList遍历时删除元素

ArrayList作为集合，一般有三种遍历方式，分别是普通for遍历，增强for遍历（foreach遍历）和迭代器遍历，采用不同的遍历方式时，有的方式可以删除元素，有的则不可以，首先结论先行：
1.for循环，可以删除元素
2.foreach循环，不可以删除元素
3.迭代器循环删除，调用iterator.remove()可以，使用list.remove()不可以
接下来分析不同方式的出现不同结果的原因：

1.使用foreach遍历

先贴代码样例：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        for(String str:list){
            System.out.println(str);
            if(str.equals("aa")){
                list.remove("aa");
            }
        }
        System.out.println(list);
    }

执行结果为：

这里有有一个很有意思的现象，就是遍历删除倒数第二个元素的时候，是可以成功删除的，并不会报错，删除其余位置的元素都会报错，代码和结果如下：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        for(String str:list){
            System.out.println(str);
            if(str.equals("cc")){
                list.remove("cc");
            }
        }
        System.out.println(list);
    }

是不是感觉很神奇，这个出现的原因后面分析

2.迭代器遍历

先贴代码样例：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
            if("aa".equals(str)){
                iterator.remove();
            }
        }
        System.out.println(list);
    }

执行结果为

这里有一个注意的点是必须使用迭代器的remove()方法，不能使用list.remove()方法，否则会抛出错误，原因同样后面分析，看一下代码样例和执行结果

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
            if("aa".equals(str)){
                list.remove("aa");
            }
        }
        System.out.println(list);
    }

3.普通for查询遍历

老规矩，先来代码样例

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        for(int i =0;i<list.size();i++){
            System.out.println(list.get(i));
            if("dd".equals(list.get(i))){
                list.remove("dd");
            }
        }
        System.out.println(list);
    }

执行结果为

4.分析原因

首先，先看一下ArrayList的继承关系图

首先继承了AbstractList类，在这个类中有一个全局变量modCount，这个变量是用来记录当list中元素变化时（新增和删除）的操作次数，当Arraylist使用foreach遍历时，会根据集合对象创建一个iterator迭代对象（在ArrayList中是一个Itr的内部类），用这个迭代对象来遍历集合，而使用迭代器遍历时主要会用到两个方法hasNext()和next()方法，ltr内部类源码如下

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        // prevent creating a synthetic constructor
        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
        	// 抛出异常的位置=========================
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
        
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
		...
    }

当迭代器遍历时，会首先调用hasNext方法，判断是否有下一个，如果为true则会调用next()方法，使用next方法首先会校验modCount和expectedModCount是否相等，如果不相等就会抛出上面执行结果的中的异常，那么为什么不相等呢，我们看一下ArrayList的remove(Obejct o)方法

public boolean remove(Object o) {
        final Object[] es = elementData;
        final int size = this.size;
        int i = 0;
        found: {
            if (o == null) {
                for (; i < size; i++)
                    if (es[i] == null)
                        break found;
            } else {
                for (; i < size; i++)
                    if (o.equals(es[i]))
                        break found;
            }
            return false;
        }
        //调用快速删除方法
        fastRemove(es, i);
        return true;
    }

在这个方法中会调用fastRemove()方法，源码如下

private void fastRemove(Object[] es, int i) {
		//每调用一次mmodCount就会自增一次
        modCount++;
        final int newSize;
        if ((newSize = size - 1) > i)
            System.arraycopy(es, i + 1, es, i, newSize - i);
        es[size = newSize] = null;
    }

我们发现每调用一次remove()方法，modCount就会自增，而expectedModCount 默认和modCount相等，当modCount自增加1，而expectedModCount 没有增加，就会抛出异常，这也就是foreach遍历时抛出的错误的原因，使用迭代器遍历，使用list.remove()抛出错误也是同样的原因，那么为什么使用foreach删除第二个元素时就能成功呢，这是因为hasNext()方法返回的结果为false，迭代器认为没有下一个元素了，就不会执行next()，就不会进行modCount和expectedModCount 的判断，上面的执行结果也能看到，当删除倒数第二个元素时，最后一个元素并没有遍历打印，这又是为什么呢？因为hasNext()方法中cursor变量的值和此时的size值相等。
cursor类似于一个游标或者指针，每进行一次遍历时就会+1,开始默认为0，以上面的代码实例，遍历第一次时，cursor=0,size=4,末尾cursor+1变成1；第二次时cursor=1，size=4,末尾cursor+1变成2;第三次时cursor=2，size=4,末尾cursor+1变成3，此时因为调用了list.remove()所以此时size-1变成了3；第四次时cursor=3，size=3，cursor=size,便不会获取最后一个元素，也就不会校验和抛出异常。
那么又为什么迭代器遍历时调用iterator.remove()不会报错呢？这是因为在iterator.remove()时会同步修改expectedModCount的值，使其和modCount的值一致，就会通过校验，不会抛出错误
使用普通for循环时，因为没有expectedModCount和modCount的比较，也就不会抛出异常

结尾

所以结论就是开始的结论，需要注意的事，前面提到过新增也会使modCount变化，而迭代器每一次遍历都会校验modCount和expectedModCount 是否一致，所以使用foreach遍历使，是不能够调用list.add()新增的，也会抛出同样的错误，这里贴一下样例和实验结果，感兴趣的朋友可以尝试一下，以上观点属于个人见解，如有问题，欢迎讨论

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        for(String str:list){
            System.out.println(str);
            list.add("ee");
        }
        System.out.println(list);
    }