作者：你呀不牛
鏈接：https://juejin.cn/post/7114669787870920734
前段時間，同事在代碼中KW掃描的時候出現這樣一條：
上面出現這樣的原因是在使用foreach對HashMap進行遍歷時，同時進行put賦值操作會有問題，例外ConcurrentModificationException，
于是幫同簡單的看了一下，印象中集合類在進行遍歷時同時進行洗掉或者添加操作時需要謹慎，一般使用迭代器進行操作，
于是告訴同事，應該使用迭代器Iterator來對集合元素進行操作，同事問我為什么？這一下子把我問蒙了？對啊，只是記得這樣用不可以，但是好像自己從來沒有細究過為什么？
于是今天決定把這個HashMap遍歷操作好好地研究一番，防止采坑！
foreach回圈？
java foreach 語法是在jdk1.5時加入的新特性，主要是當作for語法的一個增強，那么它的底層到底是怎么實作的呢？下面我們來好好研究一下：
foreach 語法內部，對collection是用iterator迭代器來實作的，對陣列是用下標遍歷來實作，Java 5 及以上的編譯器隱藏了基于iteration和陣列下標遍歷的內部實作，
（注意，這里說的是“Java編譯器”或Java語言對其實作做了隱藏，而不是某段Java代碼對其實作做了隱藏，也就是說，我們在任何一段JDK的Java代碼中都找不到這里被隱藏的實作，這里的實作，隱藏在了Java 編譯器中，查看一段foreach的Java代碼編譯成的位元組碼，從中揣測它到底是怎么實作的了）
我們寫一個例子來研究一下：
public class HashMapIteratorDemo {
String[] arr = {"aa", "bb", "cc"};
public void test1() {
for(String str : arr) {
}
}
}
將上面的例子轉為位元組碼反編譯一下（主函式部分）：
也許我們不能很清楚這些指令到底有什么作用，但是我們可以對比一下下面段代碼產生的位元組碼指令：
public class HashMapIteratorDemo2 {
String[] arr = {"aa", "bb", "cc"};
public void test1() {
for(int i = 0; i < arr.length; i++) {
String str = arr[i];
}
}
}
看看兩個位元組碼檔案，有木有發現指令幾乎相同，如果還有疑問我們再看看對集合的foreach操作：
通過foreach遍歷集合：
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();
}
}
}
將兩個方法的位元組碼對比如下：
我們發現兩個方法位元組碼指令操作幾乎一模一樣；
這樣我們可以得出以下結論：
對集合來說，由于集合都實作了Iterator迭代器，foreach語法最終被編譯器轉為了對Iterator.next()的呼叫；
對于陣列來說，就是轉化為對陣列中的每一個元素的回圈參考，
HashMap遍歷集合并對集合元素進行remove、put、add
1、現象
根據以上分析，我們知道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);
}
}
}
輸出：
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);
}
}
}
執行結果：
執行沒有問題，put操作也成功了，
但是！但是！但是！問題來了！！！
我們知道HashMap是一個執行緒不安全的集合類，如果使用foreach遍歷時，進行add，remove操作會java.util.ConcurrentModificationException例外，put操作可能會拋出該例外，（為什么說可能，這個我們后面解釋）
為什么會拋出這個例外呢？
我們先去看一下java api檔案對HasMap操作的解釋吧，
翻譯過來大致的意思就是該方法是回傳此映射中包含的鍵的集合視圖，集合由映射支持，如果在對集合進行迭代時修改了映射（通過迭代器自己的移除操作除外），則迭代的結果是未定義的，集合支持元素移除，通過Iterator.remove、set.remove、removeAll、retainal和clear操作從映射中移除相應的映射，簡單說，就是通過map.entrySet()這種方式遍歷集合時，不能對集合本身進行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);
}
}
}
執行出現例外：
這就是驗證了上面說的put操作可能會拋出java.util.ConcurrentModificationException例外，
但是有疑問了，我們上面說過foreach回圈就是通過迭代器進行的遍歷啊？為什么到這里是不可以了呢？
這里其實很簡單，原因是我們的遍歷操作底層確實是通過迭代器進行的，但是我們的remove等操作是通過直接操作map進行的，如上例子：map.put(4, "AA");//這里實際還是直接對集合進行的操作，而不是通過迭代器進行操作，所以依然會存在ConcurrentModificationException例外問題，
2、細究底層原理
我們再去看看HashMap的原始碼，通過源代碼，我們發現集合在使用Iterator進行遍歷時都會用到這個方法：
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中的元素被修改了幾次(在移除，新加元素時此值都會自增)，而expectedModCount是表示期望的修改次數，在迭代器構造的時候這兩個值是相等，如果在遍歷程序中這兩個值出現了不同步就會拋出ConcurrentModificationException例外，
現在我們來看看集合remove操作：
（1）HashMap本身的remove實作：
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 = https://www.cnblogs.com/javastack/p/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進行同步
}
以上四種方式都通過呼叫HashMap.removeNode方法來實作洗掉key的操作，在removeNode方法內只要移除了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實作中，只有第三種iterator的remove方法在呼叫完removeNode方法后同步了expectedModCount值與modCount相同，所以在遍歷下個元素呼叫nextNode方法時，iterator方式不會拋例外，
到這里是不是有一種恍然大明白的感覺呢！
所以，如果需要對集合遍歷時進行元素操作需要借助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();
}
}
}
}
近期熱文推薦：
1.1,000+ 道 Java面試題及答案整理(2022最新版)
2.勁爆！Java 協程要來了，，，
3.Spring Boot 2.x 教程，太全了！
4.別再寫滿屏的爆爆爆炸類了，試試裝飾器模式，這才是優雅的方式！！
5.《Java開發手冊（嵩山版）》最新發布，速速下載！
覺得不錯，別忘了隨手點贊+轉發哦！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/546666.html
標籤：Java
上一篇：過濾器和攔截器總結