介绍

日常开发中，难免会对集合中的元素进行移除操作，如果对这方面不熟悉的话，就可能遇到 ConcurrentModificationException，那么，如何优雅地进行元素删除？以及其它方式为什么不行？

数据初始化

public static final List<String> list = new ArrayList<>();

static {
    list.add("java");
    list.add("mysql");
    list.add("redis");
    list.add("spring");
    list.add("linux");
    list.add("git");
}

实现方式

方式一：普通 for

 @Test
 public void testRemoveFor() {
    list.add(2, "redis");
    System.out.println(list);

    for (int i = 0; i < list.size(); i++) {
        if ("redis".equals(list.get(i))) {
            list.remove(i);
        }
    }
    System.out.println(list);
}

这种方式虽然不会报错，但是会导致数据出现问题，比如 list: [java, mysql, redis, redis, spring, linux, git]

由于存在两个连续的 redis，当删除第一个时，后面的元素会向前填充，而迭代索引是一直增加的（即 i ），所以第二个 redis 没有经过检查就直接跳过了，导致最终数据为：[java, mysql, redis, spring, linux, git]

IDEA 其实也给出了我们提示（如下图）：Suspicious ‘List.remove()’ in loop；想必就是因为这个原因。

方式二：增强 for

@Test
public void testRemoveForEach() {
    for (String str : list) {
       if ("redis".equals(str)) {
            list.remove(str);
        }
    }
    System.out.println(list);
}

这种方式就直接报错了：java.util.ConcurrentModificationException

将 .class 文件反编译后以上代码对应如下（将 .class 用 IDEA 打开即可）：

Iterator var1 = list.iterator();
while(var1.hasNext()) {
	String str = (String)var1.next();
	if ("redis".equals(str)) {
		list.remove(str);
	}
}

从以上代码可以看出，for-each 实际上就是使用迭代器进行遍历元素，当在 for-each 中通过 java.util.ArrayList#remove 删除元素时，迭代器内部其实是不知道的，所以在执行 java.util.ArrayList.Itr#next() 操作时，会检查内部状态（modCount）是否一致，不一致则抛出。java.util.ConcurrentModificationException

方式三：迭代器

@Test
public void testRemoveIterator() {
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String str = iterator.next();
        if ("redis".equals(str)) {
            iterator.remove();
        }
    }
    System.out.println(list);
}

这种方式与上面 testRemoveForEach 相比，其实就只是将内部的 java.util.ArrayList#remove 换成了迭代器内部的 remove 方法，既然用的是迭代器自己的，那迭代器内部肯定就能够知道列表发生了变化，从而直接更新其内部状态，所以就不会报错了。

 /**
  * lastRet: 最后一次返回元素的索引
  * cursor：下一个返回元素的索引
  */
 public void remove() {
     if (lastRet < 0)
         throw new IllegalStateException();
     checkForComodification();
     try {
     	 // 调用 ArrayList 内部的 remove 进行删除元素，即 java.util.ArrayList#remove
         ArrayList.this.remove(lastRet);
         // 将最后一次返回元素的索引赋值给下一个返回元素的索引（因为当前元素被删除后，后面的元素前移了）
         cursor = lastRet;
         lastRet = -1;
         // remove 之后，modCount 会加一，所以需要将 modCount 赋值给 expectedModCount，从而保持一致
         expectedModCount = modCount;
     } catch (IndexOutOfBoundsException ex) {
         throw new ConcurrentModificationException();
     }
 }

方式四：反向遍历

@Test
public void testRemoveForDesc() {
    for (int i = list.size() - 1; i >= 0; i--) {
        if ("redis".equals(list.get(i))) {
            list.remove(i);
        }
    }
    System.out.println(list);
}

通过倒序的方式遍历列表并删除元素，虽然这种方式也能够实现删除元素不报错，但从性能上考虑，当删除的元素比较多时，时间复杂度会变成 O(n^2)，所以这种方式不建议使用。

方式五：removeIf

@Test
public void testRemoveIf() {
    list.removeIf("redis"::equals);
    System.out.println(list);
}

如果使用的是 JDK 1.8 及以上，建议使用这种方式删除元素，代码简洁优雅。

查看源码，removeIf 底层其实就是使用迭代器的方式进行删除。

default boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    boolean removed = false;
    final Iterator<E> each = iterator();
    while (each.hasNext()) {
        if (filter.test(each.next())) {
            each.remove();
            removed = true;
        }
    }
    return removed;
}