Java常见的遍历集合场景、方法总结和注意事项

谁借莪１个温暖的怀抱￠ 2023-09-27 17:18 6阅读 0赞

## 1、遍历List ##

*  #### for循环遍历 ####

List<String> list = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        String item = list.get(i);
        System.out.println(item);
    }

*  #### forEach遍历 ####

List<String> list = new ArrayList<>();
    for (String item : list) {
        System.out.println(item);
    }

*  #### iterator遍历 ####

List<String> list = new ArrayList<>();
    Iterator<String> it = list.iterator();
    while (it.hasNext()) {
        String item = it.next();
        System.out.println(item);
    }

1.  ## 遍历Set ##

### Set是无序的集合类型，其遍历方式和List基本相同，也包括for循环遍历、forEach、iterator遍历等。 ###

*  #### for循环遍历 ####

Set<String> set = new HashSet<>();
    for (String item : set) {
        System.out.println(item);
    }

*  #### forEach遍历 ####

Set<String> set = new HashSet<>();
    for (String item : set) {
        System.out.println(item);
    }

*  #### iterator遍历 ####

Set<String> set = new HashSet<>();
    Iterator<String> it = set.iterator();
    while (it.hasNext()) {
        String item = it.next();
        System.out.println(item);
    }

1.  ## 遍历Map ##

### Map是键值对映射的集合类型，其常用的遍历方法包括for循环遍历、forEach、iterator遍历等。 ###

*  #### for循环遍历 ####

Map<String, String> map = new HashMap<>();
    for (Map.Entry<String, String> entry : map.entrySet()) {
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + " : " + value);
    }

*  #### forEach遍历 ####

Map<String, String> map = new HashMap<>();
    map.forEach((key, value) -> System.out.println(key + " : " + value));

*  #### iterator遍历 ####

Map<String, String> map = new HashMap<>();
    Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<String, String> entry = it.next();
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + " : " + value);
    }

#### 需要注意的是，在遍历时要考虑集合的线程安全性，如果存在多个线程同时访问集合，需要使用线程安全的集合或者加锁的方式进行遍历。 ####

例如，在Java中，可以使用ConcurrentHashMap代替HashMap，或者使用CopyOnWriteArrayList代替ArrayList来实现线程安全的集合。

加锁的方式可以使用synchronized关键字或者Lock接口来实现。加锁的方式在一个线程访问共享数据时能够保证其他线程无法访问，从而保证数据的一致性。

例如，在Java中，可以使用synchronized关键字来保护共享集合的访问：

List<String> list = Collections.synchronizedList(new ArrayList<String>());
    
    synchronized (list) {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            // 针对str进行操作
        }
    }

这里使用了synchronized关键字来保护对共享集合的访问。在遍历时获取了集合的迭代器，然后使用synchronized关键字同步对集合的访问。这样，其他线程就无法访问集合，从而保证了数据的一致性。

## 遍历集合时不建议一边遍历一边删除的原因是： ##

1.  并发修改异常：若在使用Iterator遍历集合时，一边遍历一边删除元素，就会导致遍历时集合结构发生变化，从而引发ConcurrentModificationException并发修改异常。
2.  可能漏掉元素：当在遍历集合时，删除某个元素后，集合中的其他元素的索引会发生变化，这就可能导致某些元素被漏掉而没有被遍历到。

## 为了避免产生并发修改异常并确保遍历到所有元素，可以使用Iterator的remove()方法在遍历时删除元素，或者使用遍历完毕后再进行元素的删除操作。 ##

另外，在Java中也提供了线程安全的集合类，例如ConcurrentHashMap、CopyOnWriteArrayList等，在多线程并发访问时可以保证线程安全，但是在使用时仍然需要注意遍历时的并发修改问题。

当使用Iterator遍历List时，在遍历时进行删除操作会出现并发修改异常，例如下面的示例代码：

List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    
    for (Integer i : list) {
        if (i == 2) list.remove(i);
        System.out.println(i);
    }

这个代码通过for-each的方式遍历list集合，当遍历到值为2的元素时，会进行删除操作，但结果会抛出ConcurrentModificationException异常：

1
    Exception in thread "main" java.util.ConcurrentModificationException
        at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1011)
        at java.util.ArrayList$Itr.next(ArrayList.java:963)
        at com.example.demo.Main.main(Main.java:13)

为了避免这个问题，可以改用Iterator遍历并使用Iterator的remove()方法进行元素删除，例如：

List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    
    Iterator<Integer> iterator = list.iterator();
    while (iterator.hasNext()) {
        Integer i = iterator.next();
        if (i == 2) iterator.remove();
        System.out.println(i);
    }

这个代码使用Iterator迭代器遍历list集合，当遍历到值为2的元素时，使用Iterator的remove()方法进行元素删除操作，避免了并发修改异常的问题，并正常输出遍历结果：

1
    3

## 关于需要循环删除 List 中的元素，方法总结如下： ##

比如有以下这个 List：

public List<String> initList = Arrays.asList("张三", "李四", "周一", "刘四", "李强", "李白");

怎么删除 List 中姓李的人？

#### 1、普通 for 循环删除（不可靠） ####

public void remove1() {
        List<String> list = new ArrayList(initList);
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            if (str.startsWith("李")) {
                list.remove(i);
            }
        }
        System.out.println(list);
    }

输出结果：

> \[张三, 周一, 刘四, 李白\]

WC，李白没删干净？

问题就出在 list.size()，list.size() 和 i 都是动态变化的，i 的值一直在累加，list.size() 一直在减少，所以 list 就会早早结束了循环。

所以这种方式虽然不会报错，但存在隐患，并且不容易被察觉，不建议使用。

#### 2、普通 for 循环提取变量删除（抛异常） ####

把上面的示例中的 size 提出变量：

public void remove2() {
        List<String> list = new ArrayList(initList);
        int size = list.size();
        for (int i = 0; i < size; i++) {
            String str = list.get(i);
            if (str.startsWith("李")) {
                list.remove(i);
            }
        }
        System.out.println(list);
    }

输出结果：

![cda522ef1c5b417a9bc0fd0db786a763.png][]直接下标溢出了

因为 size 变量是固定的，list 的实际大小是不断减小的，而 i 的大小是不断累加的，一旦 i >= list 的实际大小肯定就异常了。

#### 3、普通 for 循环倒序删除（可靠） ####

public void remove3() {
        List<String> list = new ArrayList(initList);
        for (int i = list.size() - 1; i > 0; i--) {
            String str = list.get(i);
            if (str.startsWith("李")) {
                list.remove(i);
            }
        }
        System.out.println(list);
    }

输出结果：

> \[张三, 周一, 刘四\]

结果输出正常，这种删除方式就算把 list.size() 提出变量也是 OK 的，因为循环中只用到了一次。

#### 4、增强 for 循环删除（抛异常） ####

public void remove3() {
        List<String> list = new ArrayList(initList);
        for (String element : list) {
            if (element.startsWith("李")) {
                list.remove(element);
            }
        }
        System.out.println(list);
    }

输出结果：

![f173cfd3ec554935b56aa9e949bffed5.png][]又抛异常了。不过这次的异常和上面的下标异常不太一样，这次是：

> java.util.ConcurrentModificationException

这个是集合操作中很常见的异常之一，即并发修改异常！

其实，for(xx in xx) 就是增强的 for循环，即迭代器 Iterator 的加强实现，其内部是调用的 Iterator 的方法，为什么会报 ConcurrentModificationException 错误，我们来看下源码：

![30cabe7a916a048cf9d2031d58a60e7a.png][]

![6e00635a15f5d47b35395dbe6470521c.png][]

![8af364679b3844746cf9733621914b58.png][]

取下个元素的时候都会去判断要修改的数量（modCount）和期待修改的数量（expectedModCount）是否一致，不一致则会报错，而 ArrayList 中的 remove 方法并没有同步期待修改的数量（expectedModCount）值，所以会抛异常了。

#### 5、迭代器循环迭代器删除（可靠） ####

public void remove4() {
        List<String> list = new ArrayList(initList);
        for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
            String str = iterator.next();
            if (str.contains("李")) {
                iterator.remove();
            }
        }
        System.out.println(list);
    }

输出结果：

> \[张三, 周一, 刘四\]

结果输出正常，这是因为迭代器中的 remove 方法将期待修改的数量（expectedModCount）值进行了同步：

![4a51092986999715af970a42a0a76185.png][]

所以，这种删除方法是安全的，推荐使用。

#### 6、迭代器循环集合删除（抛异常） ####

public void remove5() {
        List<String> list = new ArrayList(initList);
        for (Iterator<String> ite = list.iterator(); ite.hasNext(); ) {
            String str = ite.next();
            if (str.contains("李")) {
                list.remove(str);
            }
        }
        System.out.println(list);
    }

输出结果：

![f2904732a1c4405b859b4ef6781ff5be.png][]又是那个并发修改异常，这个示例虽然使用了 Iterator 循环，但删除的时候却使用了 list.remove 方法，同样是有问题的，注意了，千万别用错了。

#### 7、集合 forEach 方法循环删除（抛异常） ####

public void remove6() {
        List<String> list = new ArrayList(initList);
        list.forEach((e) -> {
            if (e.contains("李")) {
                list.remove(e);
            }
        });
        System.out.println(list);
    }

输出结果：

![f15d6fc498994c37a72db1dee418f466.png][]forEach 源码：

![9c715bd6ee4c84d951d0296fdb9be79a.png][]

#### forEach 方法的背后其实就是增强的 for 循环，底层即迭代器，所以使用 list.remove 同样抛出 `ConcurrentModificationException` 异常。 ####

#### 8、stream filter 过滤（可靠） ####

public void remove7() {
        List<String> list = new ArrayList(initList);
        list = list.stream().filter(e -> !e.startsWith("李")).collect(Collectors.toList());
        System.out.println(list);
    }

输出结果：

> \[张三, 周一, 刘四\]

这个方法即是利用了 Stream 的筛选功能，快速过滤所需要的元素，虽然不是进行集合删除，但达到了同样的目的，这种方法要更简洁吧。

### 总结了 8 种循环删除 List 元素的方法： ###

*  普通 for 循环删除（不可靠）
 *  普通 for 循环提取变量删除（抛异常）
 *  **普通 for 循环倒序删除（可靠）**
 *  增强 for 循环删除（抛异常）
 *  **迭代器循环迭代器删除（可靠）**
 *  迭代器循环集合删除（抛异常）
 *  集合 forEach 方法循环删除（抛异常）
 *  **stream filter 过滤（可靠）**

参考：![7bb75275274c47b4be7d01b7c553d44c.png][]

[cda522ef1c5b417a9bc0fd0db786a763.png]: https://img-blog.csdnimg.cn/cda522ef1c5b417a9bc0fd0db786a763.png
[f173cfd3ec554935b56aa9e949bffed5.png]: https://img-blog.csdnimg.cn/f173cfd3ec554935b56aa9e949bffed5.png
[30cabe7a916a048cf9d2031d58a60e7a.png]: https://img-blog.csdnimg.cn/img_convert/30cabe7a916a048cf9d2031d58a60e7a.png
[6e00635a15f5d47b35395dbe6470521c.png]: https://img-blog.csdnimg.cn/img_convert/6e00635a15f5d47b35395dbe6470521c.png
[8af364679b3844746cf9733621914b58.png]: https://img-blog.csdnimg.cn/img_convert/8af364679b3844746cf9733621914b58.png
[4a51092986999715af970a42a0a76185.png]: https://img-blog.csdnimg.cn/img_convert/4a51092986999715af970a42a0a76185.png
[f2904732a1c4405b859b4ef6781ff5be.png]: https://img-blog.csdnimg.cn/f2904732a1c4405b859b4ef6781ff5be.png
[f15d6fc498994c37a72db1dee418f466.png]: https://img-blog.csdnimg.cn/f15d6fc498994c37a72db1dee418f466.png
[9c715bd6ee4c84d951d0296fdb9be79a.png]: https://img-blog.csdnimg.cn/img_convert/9c715bd6ee4c84d951d0296fdb9be79a.png
[7bb75275274c47b4be7d01b7c553d44c.png]: https://img-blog.csdnimg.cn/7bb75275274c47b4be7d01b7c553d44c.png