探究map为什么不能遍历的同时进行增删操作

持续创造,加速成长!这是我参与「日新方案 6 月更文应战」的第14天,点击查看活动详情

前段时间,同事在代码中KW扫描的时分呈现这样一条:

探求map为什么不能遍历的一起进行增删操作

上面呈现这样的原因是在运用foreach对HashMap进行遍历时,一起进行put赋值操数组指针作会有问题,反常ConcurrentModificationException。

所以帮同简单的看了一下,印象中调集类在进行遍历时一起进行删除或者增加操作时需求谨慎,一般运用迭代器进行操作。

所以告诉同事,应该运用迭代器Iterelement是什么意思at数组去重or来对调集元素进行操作。同事问我为什么?这一下子把我问蒙了?对啊,字节码文件扩展名仅仅记数组去重得这样用不能够,可是如同自己从来没有细究过为什么?

所以今日决定把这个HashMap遍历操作好好地研讨一番,防止采坑!

foreach循环?

java foreach源码编辑器 语法是在jdk1.5时加入的新特性,主要是当作for语法的一个增强,那么它的底层到底javaee是怎样完成的呢?下面咱们来好好研讨一下:

foreach 语法内部,对collection是用iterator迭代器来完成的,对数组是用下标遍向来完成。Java 5 及以上的编译器躲藏了数组去重依据iteration和java培训数组下标遍历的内部完成。

(注意,这儿说的是“Java编译器”或Java语言对其完成做了躲藏,而不是某段Java代码对其完成做了躲藏,也便是说,咱们在任何一段JDK的Java代码中都找不到这儿被躲藏的完成。这儿的完成,躲藏在了Java 编译器中,查看源码网站一段foreach的Java代java是什么意思码编译成的字节码,从中推测它到底是怎样完成的了)

咱们写一个比如来研讨element是什么意思一下:

public class HashMapIteratorDemo {
	String[] arr = {"aa", "bb", "cc"};
	public void test1() {
		for(String str : arr) {
		}
	}
}

将上面的比如转为字节码反编译一下(主函数部分):

探求map为什么不能遍历的一起进行增删操作

或许咱们不能很清楚这些指令Java到底有什么作用,可是咱们能够对比一下下面段代码产生的字节码指令:


public class HashMapIteratorDemo2 {
	String[] arr = {"aa", "bb", "cc"};
	public void test1() {
		for(int i = 0; i < arr.length; i++) {
			String str = arr[i];
		}
	} 
}

探求map为什么不能遍历的一起进行增删操作

看看两个字节码文件,有木有发现指令简直相同,假如还有疑问咱们再看看对调集的java模拟器foreach操作:

经过forejavaeeach遍历调集:


public class HashMapIteratorDemo3 {
	List<Integer> list = new ArrayList<>();
	public void test1() {
		list.add(1);
		list.add(2);
		list.add(3);
		for(Integer var : list) {
		}
	}
}

经过Iterator遍历调集:


public class HashMapIteratorDemo4 {
	List<Integer> list = new ArrayList<>();
	public void test1() {
		list.add(1);
		list.add(2);
		list.add(3);
		Iterator<Integer> it = list.iterator();
		while(it.hasNext()) {
			Integer var = it.next();
		}
	}
}

将两个办法的字节码对比如下:

探求map为什么不能遍历的一起进行增删操作

探求map为什么不能遍历的一起进行增删操作

咱们发现两个办法字节码指令操作简直一模一字节码样;

这样咱们能够得出以下定论:

对调集来说,因为调集都完成了Iterator迭代器,foreach语法终究被编译器转为了对Iterator.next()的调用;

关于数组来说,便是转化为对数组中的每一个元素的循环引证。

Has字节码是什么意思hMap遍历调集并对调集元素进elementary是什么意思行remove、put、add

1、现象

依据elementanimation以上分析,咱们知道HashMap底层是完成了Iterator迭代器的 ,那么理论上咱们也是能够运用数组和链表的区别迭代器进行遍历的,这倒是不假,例如下面:


public class HashMapIteratorDemo5 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "aa");
		map.put(2, "bb");
		map.put(3, "cc");
		for(Map.Entry<Integer, String> entry : map.entrySet()){  
		    int k=entry.getKey();  
		    String v=entry.getValue();  
		    System.out.println(k+" = "+v);  
		}  
	} 
}

输出:

探求map为什么不能遍历的一起进行增删操作

ok,遍历没有问题,那么操作调集元素remove、put、add呢?


public class HashMapIteratorDemo5 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "aa");
		map.put(2, "bb");
		map.put(3, "cc");
		for(Map.Entry<Integer, String> entry : map.entrySet()){  
		    int k=entry.getKey();  
		    if(k == 1) {
		    	map.put(1, "AA");
		    }
		    String v=entry.getValue();  
		    System.out.println(k+" = "+v);  
		}  
	} 
}

履行成果:

探求map为什么不能遍历的一起进行增删操作

履行没有问题,put操作也成功了。

可是!可是!可是!问题来了!!!

咱们源码之家知道HashMap是一个线程不源码1688安全的调集类,假如运用foreach遍历时,进行add,remove操作会java.utilJava.ConcurrentModificationException反常。javascriptput操作Element可能会抛出该反常。(为什么说可能,这源码编程器个咱们后面解释)

为什么会抛出这个反常呢?

咱们先去看一下java api文档对源码编辑器下载HasMap操作的解释吧。

探求map为什么不能遍历的一起进行增删操作

翻译过来大致的意思便是该办法是返回此映射中包括的键的调集视图。调集由映射支javaee撑,假如在数组对调集进行迭代时修正了映射(经过迭代器自己的移除操作除外),则迭代的成果是未定义的。调集支撑元素移除,经过Iterator.remove、set.remove、removeAll、retainal和clear操作从映数组指针射中移除相应的映射。简单说,便是经过map.entry数组排序Set()这种办法遍历调集时,不能对调集自身进行remove、add等操作,需求运用迭代器进行操作。

关于put操作,假如这个操作时替换操作如上例中将第一个元素进行修正,就没有抛出反常,可是假如是运用put增加元素的操作,则肯定会抛出反常了。咱们把上面的比如修正一下:


public class HashMapIteratorDemo5 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "aa");
		map.put(2, "bb");
		map.put(3, "cc");
		for(Map.Entry<Integer, String> entry : map.entrySet()){  
		    int k=entry.getKey();  
		    if(k == 1) {
		    	map.put(4, "AA");
		    }
		    String v=entry.getValue();  
		    System.out.println(k+" = "+v);  
		}  
	} 
}

履行呈现反常:

探求map为什么不能遍历的一起进行增删操作

这便是验证了上面说的put操作可能会抛出java.util.ConcuelementuirrentModific数组词ationException反常。

可是有疑问了,咱们上面说过foreach循环便是经过迭element滑板代器进行的遍历啊?为什么到这儿是不能够了呢?

这儿其实很简单,原因是咱们的遍历操作element滑板底层确实是经过迭代器进行的,可是咱们的remove等操作是经过直接操作map进行的,如上比如:map.put(4, “AA”);//这儿实践还是直接对调集进行的数组操作,而不是经过迭代器进行操作。所以仍然会存在ConcurrentModificationException反常问题。

2、细究底层原理

咱们再去看看HashMap的源码,经过源代码,咱们发现调集在运用Iterat源码or进行遍历时都会elementary翻译用到这个办法:

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

这儿modCount是表示数组和链表的区别map中的元素被修正了几回(在移除,新加元素时此值都会自增),而expecteelementanimationdModCount是表示期望的修正次数,在迭代器结构的时分这两个值是相等,假如在遍历过程中这两个值呈现了不同步就会抛出ConcurrentModificjava培训ationExcepjava怎么读tion反常。

现在咱们来看看调集remove操作:

(1)HashMap自身的remove完成:

探求map为什么不能遍历的一起进行增删操作

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

(2)HashMap.源码编程器KeySet的remove完成

public final boolean remove(Object key) {
    return removeNode(hash(key), key, null, false, true) != null;
}

(3)HashMap.EntrySet的remove完成

public final boolean remove(Object o) {
    if (o instanceof Map.Entry) {
        Map.Entry<?,?> e = (Map.Entry<?,?>) o;
        Object key = e.getKey();
        Object value = e.getValue();
        return removeNode(hash(key), key, value, true, true) != null;
    }
    return false;
}

(4)HashMap.HashIterator的remove办法完成

public final void remove() {
    Node<K,V> p = current;
    if (p == null)
        throw new IllegalStateException();
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    current = null;
    K key = p.key;
    removeNode(hash(key), key, null, false, false);
    expectedModCount = modCount; //----------------这儿将expectedModCount 与modCount进行同步
}

以上四种办法都经过调用HashMelementaryap.removeNode办法来完成删数组公式除key的操作。在removeNode办法内element是什么意思只要移除源码编辑器了key, modCount就会履行一次自增操作,此时modCount就与expectedModCount不一致了;

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 &&
        ...
        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;   //------------------------这儿对modCount进行了自增,可能会导致后面与expectedModCount不一致
            --size;
            afterNodeRemoval(node);
            return node;
        }
        }
        return null;
   }

上面三种remove完成中,只有第三种ite源码编辑器下载rator的remove办法在调用完reelementary是什么意思moveNode办法后同步了expectedModCjava怎么读ount值与modCount相同,所以在遍历java是什么意思下个元素调用nextNode办法时,iterator办法不会Element抛反常。

到这儿是不是有一种恍然大明白elementary是什么意思的感觉呢!

所以,假如需求对调集遍历时进行元素操作需求凭借Iterator迭代器进行,如下:

public class HashMapIteratorDemo5 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "aa");
		map.put(2, "bb");
		map.put(3, "cc");
		//		for(Map.Entry<Integer, String> entry : map.entrySet()){  //		    int k=entry.getKey();  //		    //		    if(k == 1) {//		    	map.put(1, "AA");//		    }//		    String v=entry.getValue();  //		    System.out.println(k+" = "+v);  //		}  
		Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
		while(it.hasNext()){
			Map.Entry<Integer, String> entry = it.next();
			int key=entry.getKey();  
	        if(key == 1){  
	            it.remove();        
	        }  
		}
	}
}

发表回复

提供最优质的资源集合

立即查看 了解详情