HashMap遍历中删除元素报错

拼搏现实的明天。 2024-03-31 10:55 58阅读 0赞

#### 文章目录 ####

*  一、问题描述
 *  二、问题分析
 *  三、解决问题
 *  四、相关问题

## 一、问题描述 ##

HashMap在遍历的时候进行删除元素报错java.util.ConcurrentModificationException。

## 二、问题分析 ##

代码如下：

public class DemoTest {
        
        public static void main(String[] args) {
        
            HashMap<String, String> map = new HashMap<>();
            map.put("xiaoming","1");
            map.put("xiaoliang","2");
            map.put("xiaodu","3");
            //第一种方式：froeach遍历map集合，并且在遍历过程中删除元素
            //然后抛出异常java.util.ConcurrentModificationException
            for (Map.Entry<String,String> entry: map.entrySet()) {
        
                System.out.println(entry.getKey()+entry.getValue());
                map.remove(entry.getKey());//这里删除元素
            }
        }
    }

可以推测，由于我们在遍历HashMap的元素过程中删除了当前所在元素，下一个待访问的元素的指针也由此丢失了。

具体分析：foreach循环

上面代码编译后查看.class文件，代码如下

public static void main(String[] args) {
        
            HashMap<String, String> map = new HashMap();
            map.put("xiaoming", "1");
            map.put("xiaoliang", "2");
            map.put("xiaodu", "3");
           //foreach实际上还是Iterator
            Iterator var2 = map.entrySet().iterator();
    
            while(var2.hasNext()) {
        
                Entry<String, String> entry = (Entry)var2.next();
                System.out.println((String)entry.getKey() + (String)entry.getValue());
                map.remove(entry.getKey());
            }
        }

打断点测试

![在这里插入图片描述][8a7b9bdfbcf347dc9763302c0869d731.png_pic_center]

**发现modCount=4 != expectedModeCount=3 就抛出异常。**

我们深入研究

这段代码是remove移除元素的时候，modCount会做++操作。

final Node<K,V> removeNode(int hash, Object key, Object value,
                                   boolean matchValue, boolean movable) {
        
            Node<K,V>[] tab; Node<K,V> p; int n, index;
            if ((tab = table) != null && (n = tab.length) > 0 &&
                (p = tab[index = (n - 1) & hash]) != null) {
        
                Node<K,V> node = null, e; K k; V v;
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    node = p;
                else if ((e = p.next) != null) {
        
                    if (p instanceof TreeNode)
                        node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                    else {
        
                        do {
        
                            if (e.hash == hash &&
                                ((k = e.key) == key ||
                                 (key != null && key.equals(k)))) {
        
                                node = e;
                                break;
                            }
                            p = e;
                        } while ((e = e.next) != null);
                    }
                }
                if (node != null && (!matchValue || (v = node.value) == value ||
                                     (value != null && value.equals(v)))) {
        
                    if (node instanceof TreeNode)
                        ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                    else if (node == p)
                        tab[index] = node.next;
                    else
                        p.next = node.next;
                    ++modCount;//注意这里
                    --size;
                    afterNodeRemoval(node);
                    return node;
                }
            }
            return null;
        }

remove完后接着判断下一个元素，然后获取下一个元素的时候，就在这里抛出异常。代码如下

final Node<K,V> nextNode() {
        
                Node<K,V>[] t;
                Node<K,V> e = next;
                if (modCount != expectedModCount)//注意这里
                    throw new ConcurrentModificationException();
                if (e == null)
                    throw new NoSuchElementException();
                if ((next = (current = e).next) == null && (t = table) != null) {
        
                    do {
        } while (index < t.length && (next = t[index++]) == null);
                }
                return e;
            }

会发现它并没有使expectedModCount++，就报错Exception in thread “main” java.util.ConcurrentModificationException。

那怎么解决呢？

## 三、解决问题 ##

使用[迭代器][Link 1]删除，代码如下：

public class DemoTest {
        
        public static void main(String[] args) {
        
            HashMap<String, String> map = new HashMap<>();
            map.put("xiaoming","1");
            map.put("xiaoliang","2");
            map.put("xiaodu","3");
            Iterator var2 = map.entrySet().iterator();
            while(var2.hasNext()) {
        
                Map.Entry<String, String> entry = (Map.Entry)var2.next();
                System.out.println((String)entry.getKey() + (String)entry.getValue());
    //            map.remove(entry.getKey());
                var2.remove();//迭代器删除,不报错
            }
        }
    }

## 四、相关问题 ##

ArrayList也是一样的问题，在使用foreach遍历中进行删除的时候，会抛出异常。

代码如下：

public class DemoTest {
        
        public static void main(String[] args) {
        
            List<String> list = new ArrayList<>();
            list.add("xiaoming");
            list.add("xiaoming");
            list.add("xiaoming");
            for (String str:list) {
        
                System.out.println(str);
                list.remove(str);
            }
        }
    }
    //抛出异常：Exception in thread "main" java.util.ConcurrentModificationException

另一种写法，不会报错，但是也会导致问题：第二个元素删除不掉

public class DemoTest {
        
        public static void main(String[] args) {
        
            List<String> list = new ArrayList<>();
            list.add("xiaoming");
            list.add("xiaoliang");
            list.add("xiaodu");
            System.out.println(list.toString()+list.size());
            for (int i = 0; i < list.size(); i++) {
        
                System.out.println(list.get(i));
                list.remove(i);
            }
            System.out.println(list.toString());
        }
        /*
         结果：
            [xiaoming, xiaoliang, xiaodu]3
            xiaoming
            xiaodu
            [xiaoliang]
         问题：少删了一个。
         **/
    }

编译后的文件代码如下：

public static void main(String[] args) {
        
            List<String> list = new ArrayList();
            list.add("xiaoming");
            list.add("xiaoming");
            list.add("xiaoming");
            Iterator var2 = list.iterator();
    
            while(var2.hasNext()) {
        
                String str = (String)var2.next();
                System.out.println(str);
                list.remove(str);
            }
    
        }

其实foreach本质上就是会调用Iterator方法。在 list.remove(str);移除的操作中，modCount会变 、 expectedModeCount不会变。我们采用var2.remove();//迭代器删除,不报错,因为它里面对expectedModCount做了+1操作，正好跟modCount相等，就不报错。

解决方案：

public class DemoTest {
        
        public static void main(String[] args) {
        
            List<String> list = new ArrayList<>();
            list.add("xiaoming");
            list.add("xiaoliang");
            list.add("xiaodu");
            System.out.println(list.toString()+list.size());
            Iterator var2 = list.iterator();
    
            while(var2.hasNext()) {
        
                String str = (String)var2.next();
                System.out.println(str);
                var2.remove();
            }
            System.out.println(list.toString());
        }
        /*
         结果：
            [xiaoming, xiaoliang, xiaodu]3
            xiaoming
            xiaoliang
            xiaodu
            []
         **/
    }

或者使用[CopyOnWriteArrayList][]

[8a7b9bdfbcf347dc9763302c0869d731.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d50bd019de6147e09be87f8a2be09fda.png
[Link 1]: https://www.runoob.com/java/java-iterator.html
[CopyOnWriteArrayList]: https://blog.csdn.net/li_w_ch/article/details/112668551