Java List 删除元素的陷阱

List 删除元素，常常第一反应就是for循环，通过if条件判断，调用List.remove(i) 或者 List.remove(Object) 的方式来完成移除集合上的元素。

public static void main(String[] args) {
    List<String> list = new ArrayList(2) {
        {
            add("a");
            add("b");
        }
    };
    for (int i = 0; i < list.size(); i++) {
        if ("a".equals(list.get(i))) {
            list.remove(i);
        }
    }
    list.forEach(System.out::println);
}
Console:
    b

Process finished with exit code 0

但其实这上面是有一个逻辑陷阱的。这个陷阱其实一点不复杂，只是作为自身的提醒。我稍微修改一下上面的代码。

public static void main(String[] args) {
    List<String> list = new ArrayList(2) {
        {
            add("a");
            add("b");
            add("a");
            add("a");
        }
    };
    for (int i = 0; i < list.size(); i++) {
        if ("a".equals(list.get(i))) {
            list.remove(i);
        }
    }
    list.forEach(System.out::println);
}
Console:
    b
    a

Process finished with exit code 0

厚礼蟹，明明指定删除字符串 a ，为何却只是删除了其中的两个的呢？这就是这个陷阱，一切缘由来自一个方法，list.size() 长度的方法。掉进这个陷阱是因为我们默认了完成这次循环长度是不变的，但随着remove() 的发生：

// ArrayList 的源码
public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

这个源码最简单的理解就是，执行完 --size 操作符，数组的长度会随即更新，下次再调用size()的时候便出现了边界缩小的问题，我们可以清楚的推理出其中的问题:

 // 初始：[a, b, a, a] list.size = 4; 循环条件是 i < size; i++;
 // 第一次[i = 0 < size]判断出 list[0] = "a"; 符合条件 ，因此数组变成 [b, a, a] list.size = 3;
 // 第二次[i = 1 < size]判断出 list[1] = "b", 不符合条件，数组并未发生改变。
 // 第三次[i = 2 < size]判断出 list[0] = "a"; 符合条件 ，因此数组变成 [b, a] list.size = 2;
 // 第四次[i = 3 > size]不符合循环的条件，于是break;出循环，因此数组定格在[b, a] list.size = 2;

因此结果并非是我们最开始的期望，是因为忽略了size随着数组的变化而产生的问题，但这个并不是说明这个方法是不对的，只能说明是不安全的有缺陷的方法，因为当这个方法面对一些List集合也能完成相同的责任，比如能保证符合条件的元素只是出现一次，这个方法也是游刃有余。

好了，讲完了陷阱问题，那么我们怎么才能保证安全的呢？

A. 很简单的方式，在原来的方法倒转思维，既然我们顺序数组会发生不安全的问题，那么我改成倒序咯，因为与正序而言，最大的不同是我已经知道了i的尽头是0，因此能够保证完成元素的循环。

public static void main(String[] args) {
    List<String> list = new ArrayList(2) {
        {
            add("a");
            add("b");
            add("a");
            add("a");
        }
    };
    for (int i = list.size() - 1; i >= 0; i--) {
        if ("a".equals(list.get(i))) {
            list.remove(i);
        }
    }
    list.forEach(System.out::println);
}
Console:
    b

Process finished with exit code 0

B. 使用迭代器完成.

public static void main(String[] args) {
    List<String> list = new ArrayList(2) {
        {
            add("a");
            add("b");
            add("a");
            add("a");
        }
    };
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        if ("a".equals(iterator.next())) {
            iterator.remove();
        }
    }
    list.forEach(System.out::println);
}
Console:
    b

Process finished with exit code 0

可是，为什么迭代器能够完成这个工作？我们去阅读 list.iterator() 得知：

public Iterator<E> iterator() {
    return new Itr();
}
/**
 * 复制源码的部分代码而已
 * An optimized version of AbstractList.Itr
 */
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;

我们可以简单的看出并提出一个结论，迭代器是一个对象，实质只是一个实例化出一个操作List的对象，不再是我们直接操作 list。那再看看 iterator.hasNext();

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

只是简单判断是 cursor 是不是等于本身这个list的size相同,并不能知道太多信息。那看看 iterator.next()

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];
}

简单的阅读就是 获取数组本身，因为int默认是0 ，因此创建的迭代器cursor是0开始计算，并操作完都+1，并赋值到 lastRet 变量，定位最后最后一次操作的游标。但还需看完主角 iterator.remove();

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();
    }
}

简单的理解，因为 cursor = lastRet; 所以我们可以知道删除元素之后，迭代器并未往前一步，游标还是停止到最后一次操作上，因此我们清楚了当发生了remove()发生，cursor只是停留在最后一次操作的位置上，当新的数组填充完，next() 获取还是最后一次操作的位置，只是里面的元素发生更变。所以迭代器完成删除元素是安全的。

C. Java8 之后 使用流的概念 || removeIf() 完成集合的操作。

// 方法1 使用 filter() 方法过滤元素。filter() 只保留符合条件的，因此我们的条件变成 !"a".equals(s).
public static void main(String[] args) {
    List<String> list = new ArrayList(2) {
        {
            add("a");
            add("b");
            add("a");
            add("a");
        }
    };
    list = list.stream().filter(s -> !"a".equals(s)).collect(Collectors.toList());
    list.forEach(System.out::println);
}
Console:
    b

Process finished with exit code 0
==============================================================================================================
 // 方法2 使用 removeIf()
 public static void main(String[] args) {
    List<String> list = new ArrayList(2) {
        {
            add("a");
            add("b");
            add("a");
            add("a");
        }
    };
    list.removeIf(s -> "a".equals(s));
    list.forEach(System.out::println);
}
Console:
    b

Process finished with exit code 0

Stream 的概念是很好用Java8之后很好用的东西，我理解的流就如同其名，只是一个数据流，用完就变成你想要我变成的样子，或者完成迭代，或者完成集合元素的新增删除修改，更或者合并另外的数据流。
并不是说是多么高效的性能操作，你使用底层的数组或者集合操作也能完成相同的效果，性能可能比数据流更好，但我这里提到的是流的概念，其实就是想把集合的操作实现成流水线的代码，让我们更清晰的更简洁的看出这个集合的”变化史“，对于我来说是更简洁更干净的编程习惯。对于我来说，代码本身是自由的，如同无尽的荒野那样广阔，能够带领自己不迷失在里面的是编程思想，并不是死记硬背的代码。

removeIf() 是Java 8 的才添加上去的方法，变量其实是通过 lamda 表达式放入匿名方法，这个方法就是 携带 String s 的匿名方法 ，方法体就是 “a”.equals(s); 翻译成 代码就是

public boolean method (String s) {
    return "a".equals(s);
}

这个展开的话，其实很简单的知道，底层方法还是使用迭代器去完成操作，只是可能涉及到另外一个编程方式：函数式编程。Java8 lambda表达式其实就是简化匿名函数的编写，看起来很高大上（我第一次见也这样觉得），但单纯的使用他当然可以，但为什么出现他，我理解这个大概是Java的团队也想提升Java在函数式编程的支持吧？！因为lambda表达式确实使匿名函数更加简洁，用的好也能减少一些对象的创建。
我也是在18年（刚出来工作）的时间里认识了函数式编程，虽然Java8对这个完成了支持，但我们这帮新人里面几乎不清楚函数式编程这个思想，我告诉他们，也只是觉得新东西让我觉得很高大上，但实际工作Java的代码依旧还是面向对象编程，那时候我并不意识到函数式编程对我产生如此大的影响。
我其实现在也不能说完整的解释什么是函数式编程，我理解的函数式编程是 函数是第一公民，就是函数是最重要的，函数其实就是如同变量一样，他们可以如同变量那样操作，每个函数是纯粹的 ，这点几乎是影响我到现在的思想，我认同每个函数是纯粹的，我通常希望传递一个参数给函数，函数只会回应我相同的答案，不应该受到外部的影响而导致我传递的参数得到的结果是不同的。
面向对象编程思想当然使得代码更加容易读懂，但代码的复杂度重复度的风险也随即提高，这是很多新人不能够意识到的问题，虽然Java单纯的使用函数式编程是不合理且不合适的，毕竟已经这么久的面向对象编程，所以我更倾向两种混合使用，我写代码的时候更期望更够像函数式编程一样，每个函数，每个接口是纯粹的，函数需要完成什么样的计算，完成什么样的责任都需要提前预先想好，再编码，但实现函数的方式如果需要用到面向对象，还是毫不犹豫的使用。
这个就和我前面提到的，代码本身是自由的，如同无尽的荒野那样广阔，影响你的往往不是市面上那些眼花缭乱的技术或者产品，而应该是编程思想。后面这些话当然已经偏离主题了，当我还是想分享下当下的感受，因为我也不知道未来是怎么样的，公司不会在意你使用的什么思想什么技术。知识永远学不完，我也不希望我只学会一些编程的思想，家庭啊，社会啊，宇宙啊，还有大把可以值得思考的问题。

以上都是我不成熟的见解，希望提醒提醒自己。纯手打的，有误不改（\dog）