集合遍历有多种方式，但各种方式执行效率上稍有差别，遍历集合时删除元素处理不当会有一些问题，这里详细汇总一下。
遍历集合
遍历集合元素的方式主要有以下几种：
- 使用一般的for循环遍历集合
- 使用for-each循环遍历集合
- 使用Iterator迭代器提供的hasNext、next方法遍历集合
- 使用Java 8 为Iterator接口提供的forEachRemaining默认方法遍历集合
- 使用Java 8 为Iterable接口提供的forEach默认方法遍历集合
- 使用Java 8 提供的流式API遍历集合
这里以ArrayList为例来测试以上几种方式。
先创建一个集合元素类。
public class Student {
private int id;
private String name;
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
public Student(int id, String name) {
this.id = id;
this.name = name;
}
省略getter和setter方法
}
再创建一个遍历集合的测试类：
public class IterateCollectionTest {
private static final int LIST_SIZE = 10000;
private static final int ITERATE_TIMES = 1000;
private static final int CONDITION_NUM = 2;
public static void main(String[] args) {
forIterate();
forEachIterate();
iteratorIterate();
iteratorForEachRemainingMethodIterate();
forEachMethodIterate();
streamIterate();
}
/**
* 使用一般的for循环遍历集合元素
*/
public static void forIterate() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "student" + i));
}
long millionSeconds = System.currentTimeMillis();
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);
if (student.getId() % CONDITION_NUM == 0) {
for (int j = 0; j < ITERATE_TIMES; ) {
j++;
}
}
}
System.out.println("forIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 使用for-each循环遍历集合元素
*/
public static void forEachIterate() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "student" + i));
}
long millionSeconds = System.currentTimeMillis();
for (Student student : list) {
if (student.getId() % CONDITION_NUM == 0) {
for (int j = 0; j < ITERATE_TIMES; ) {
j++;
}
}
}
System.out.println("forEachIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 使用Iterator迭代器来遍历结合元素
*/
public static void iteratorIterate() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "student" + i));
}
long millionSeconds = System.currentTimeMillis();
Iterator<Student> iterator = list.iterator();
while (iterator.hasNext()) {
Student student = iterator.next();
if (student.getId() % CONDITION_NUM == 0) {
for (int j = 0; j < ITERATE_TIMES; ) {
j++;
}
}
}
System.out.println("iteratorIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 使用Java 8 为Iterator接口提供的forEachRemaining默认方法来遍历集合元素
* 该方法是使用Iterator的hasNext、next方法，以及函数式接口Consumer实现的
* 该方法可依据指定的迭代顺序（如果指定了的话）来遍历处理集合元素，所以效率较低
* 这里可以使用Java 8新增的Lambda表达式来简化编程
*/
public static void iteratorForEachRemainingMethodIterate() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "student" + i));
}
long millionSeconds = System.currentTimeMillis();
list.iterator().forEachRemaining(student -> {
if (student.getId() % CONDITION_NUM == 0) {
for (int j = 0; j < ITERATE_TIMES; ) {
j++;
}
}
});
System.out.println("iteratorForEachRemainingMethodIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 使用Java 8 为Iterable接口提供的forEach默认方法来遍历集合元素
* 该方法使用for-each循环来实现遍历，在这几种方法中速度最快
* 这里可以使用Java 8新增的Lambda表达式来简化编程
*/
public static void forEachMethodIterate() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "student" + i));
}
long millionSeconds = System.currentTimeMillis();
list.forEach(student -> {
if (student.getId() % CONDITION_NUM == 0) {
for (int j = 0; j < ITERATE_TIMES; ) {
j++;
}
}
});
System.out.println("forEachMethodIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 使用Java 8 提供的流式API来遍历集合
* 流式API将集合转换成流，遍历速度仅次于Iterable接口提供的forEach默认方法。
*/
public static void streamIterate() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "student" + i));
}
long millionSeconds = System.currentTimeMillis();
list.stream().forEach(student -> {
if (student.getId() % CONDITION_NUM == 0) {
for (int j = 0; j < ITERATE_TIMES; ) {
j++;
}
}
});
System.out.println("streamIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
}
在我的i5-6500CPU电脑上多次测试取遍历操作耗时的平均值，得出这几种方法的遍历速度从快到慢依次为：
forEachMethodIterate > streamIterate > iteratorIterate > forEachIterate > forIterate > iteratorForEachRemainingMethodIterate
所以如果遍历一个集合中元素，建议优先使用Java 8为Iterable接口提供的forEach默认方法。如果你还未使用Java 8，则建议优先使用Iterator接口的hasNex和next方法来实现遍历。
遍历集合时动态删除集合中的元素
遍历集合删除集合元素的方式有以下几种：
- 使用一般的for循环遍历删除，同时手动处理因删除操作导致集合大小变化的问题
- 使用一般的for循环逆序遍历删除，不用手动处理因删除操作导致集合大小变化的问题
- 使用官方推荐的Iterator迭代器提供的Iterator.remove方法在遍历集合时删除集合元素
- 使用Java 8新增的removeIf方法在遍历集合时删除集合元素
- 使用Java 8提供的流式API来筛选元素，然后转换成集合类型
这里以ArrayList为例来测试以上几种方式。
public class RemoveElementInListTest {
private static final int LIST_SIZE = 20000;
private static final int CONDITION_NUM = 2;
public static void main(String[] args) {
// 以下三种方式都不能正常地遍历删除
// forEachRemove();
// forEachBreakRemove();
// forRemove();
// 以下几种方式可以正常地遍历删除
forRemoveNoSkipping();
forReverseRemoveNoSkipping();
iteratorRemove();
ifRemove();
streamRemove();
}
/**
* 使用foreach遍历删除
* 在第一次循环时删除List中的元素删除不会出现问题，但继续循环List时会报ConcurrentModificationException
* 从打印的异常信息来看，forEach循环集合时使用了某种内部索引器
* 可以使用线程安全的CopyOnWriteArrayList来代替ArrayList
* 但是当List中元素很多时效率会大大折扣，还会造成资源浪费
*/
public static void forEachRemove() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "Student" + i));
}
for (Student student : list) {
if (student.getId() % CONDITION_NUM == 0) {
list.remove(student);
}
}
}
/**
* 使用foreach循环对List进行遍历删除，但删除之后马上就跳出的就不会出现异常
* 但这种方式在需要删除多个元素的情况下无法满足要求
*/
public static void forEachBreakRemove() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "Student" + i));
}
for (Student student : list) {
if (student.getId() % CONDITION_NUM == 0) {
list.remove(student);
break;
}
}
}
/**
* 一般的for循环遍历有可能会遗漏某个元素，因为删除元素后List的size在变化，元素的索引也在变化
* 比如你循环到第2个元素的时候你把它删了，接下来你去访问第3个元素，实际上访问到的是原先的第4个元素
* 当访问的元素索引超过了当前的List的size后还会出现数组越界的异常，当然这里不会出现这种异常
* 因为这里每遍历一次都重新获取一次当前List的size
*/
public static void forRemove() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "Student" + i));
}
for (int i = 0; i < list.size(); i++) {
if (list.get(i).getId() % CONDITION_NUM == 0) {
list.remove(i);
}
}
}
/**
* 手动处理一般的for循环遍历时删除而导致的索引变化就可以安全地删除
*/
public static void forRemoveNoSkipping() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "Student" + i));
}
long millionSeconds = System.currentTimeMillis();
for (int i = 0; i < list.size(); i++) {
if (list.get(i).getId() % CONDITION_NUM == 0) {
list.remove(i);
// 删除某个元素会导致list的size减1，手动使遍历位置后移一个位置
// 这样就不会漏掉被删除元素后面的元素
i--;
}
}
System.out.println("forRemoveNoSkipping操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 使用反向的for循环遍历时删除就无需手动处理索引变化的问题
* 而且因为删除操作而导致的元素移动也比正向遍历要少
*/
public static void forReverseRemoveNoSkipping() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "Student" + i));
}
long millionSeconds = System.currentTimeMillis();
for (int i = list.size() - 1; i >= 0; i--) {
if (list.get(i).getId() % CONDITION_NUM == 0) {
list.remove(i);
}
}
System.out.println("forReverseRemoveNoSkipping操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 使用Iterator的方式也可以顺利删除和遍历，不会有任何问题，这才是删除变量List中元素的正确方式
*/
public static void iteratorRemove() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "Student" + i));
}
Iterator<Student> iterator = list.iterator();
long millionSeconds = System.currentTimeMillis();
while (iterator.hasNext()) {
Student student = iterator.next();
if (student.getId() % CONDITION_NUM == 0) {
iterator.remove();
}
}
System.out.println("iteratorRemove操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 也可以使用Java 8新增的removeIf方法在遍历时删除List中的元素，该方法也使用Iterator了，所以删除是安全的
*/
public static void ifRemove() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "Student" + i));
}
long millionSeconds = System.currentTimeMillis();
list.removeIf(student -> student.getId() % CONDITION_NUM == 0);
System.out.println("ifRemove操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
/**
* 使用Java 8提供的流式API来筛选元素和转换成集合类型
* 从Java 8开始，使用流式API遍历集合是首选的方式，这种方式用于遍历非常快
* 但由于创建了流，这种方式增大了空间开销
*/
public static void streamRemove() {
List<Student> list = new ArrayList<>();
for (int i = 1; i <= LIST_SIZE; i++) {
list.add(new Student(i, "Student" + i));
}
long millionSeconds = System.currentTimeMillis();
list.stream()
.filter(student -> student.getId() % CONDITION_NUM == 0)
.collect(Collectors.toList());
System.out.println("streamRemove操作耗时：" + (System.currentTimeMillis() - millionSeconds));
}
}
在我的电脑上多次测试取耗时的平均值，得出这几种方法的遍历速度从快到慢依次为：
streamRemove > forReverseRemoveNoSkipping > iteratorRemove > forRemoveNoSkipping > ifRemove
其中，iteratorRemove和forRemoveNoSkipping的测试结果很接近，大家可以自行修改集合大小的常量亲自测试，如有问题欢迎反馈。
所以如果遍历一个集合时删除其中的元素，建议优先使用Java 8提供的流式API来筛选集合元素。如果你还未使用Java 8，则建议优先使用逆序的一般for循环来实现遍历时删除集合元素。
许多初学者容易使用上面示例中的前三种方式来在遍历集合时删除集合元素，但是得不到正确的结果，原因已经在这三种方法的注释中说明了。对于使用for-each循环时抛出ConcurrentModificationException异常的原因可通过查看ArrayList.remove()方法的源码来探明。for-each循环List集合时使用了一个实现了Iterator接口的ArrayList内部类对象来实现遍历，该内部类源码如下：
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;
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();
}
}
使用for-each遍历时调用该内部类的next方法，进而调用该方法中第一行的checkForComodification方法，ConcurrentModificationException异常就是在这个checkForComodification方法中抛出的：
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
当我们显式调用remove方法来删除集合中的元素时会修改modCount的值，使其与expectedModCount不一致：
public E remove(int index) {
rangeCheck(index);
checkForComodification();
E result = l.remove(index+offset);
this.modCount = l.modCount;
size--;
return result;
}
官方教程也有说在以下情况中可以使用Iterator来代替for-each循环：
- 删除集合元素时。for-each循环使用隐藏了迭代器，所以遍历删除失败。
- 并行迭代多个集合对象时。
