Java?map為什么不能遍歷的同時進行增刪操作
前段時間，同事在代碼中KW掃描的時候出現(xiàn)這樣一條：
上面出現(xiàn)這樣的原因是在使用foreach對HashMap進行遍歷時，同時進行put賦值操作會有問題，異常ConcurrentModificationException。
于是幫同簡單的看了一下，印象中集合類在進行遍歷時同時進行刪除或者添加操作時需要謹慎，一般使用迭代器進行操作。
于是告訴同事，應該使用迭代器Iterator來對集合元素進行操作。同事問我為什么？這一下子把我問蒙了？對啊，只是記得這樣用不可以，但是好像自己從來沒有細究過為什么？
于是今天決定把這個HashMap遍歷操作好好地研究一番，防止采坑！
foreach循環(huán)？
java foreach 語法是在jdk1.5時加入的新特性，主要是當作for語法的一個增強，那么它的底層到底是怎么實現(xiàn)的呢？下面我們來好好研究一下：
foreach 語法內(nèi)部，對collection是用iterator迭代器來實現(xiàn)的，對數(shù)組是用下標遍歷來實現(xiàn)。Java 5 及以上的編譯器隱藏了基于iteration和數(shù)組下標遍歷的內(nèi)部實現(xiàn)。
（注意，這里說的是“Java編譯器”或Java語言對其實現(xiàn)做了隱藏，而不是某段Java代碼對其實現(xiàn)做了隱藏，也就是說，我們在任何一段JDK的Java代碼中都找不到這里被隱藏的實現(xiàn)。這里的實現(xiàn)，隱藏在了Java 編譯器中，查看一段foreach的Java代碼編譯成的字節(jié)碼，從中揣測它到底是怎么實現(xiàn)的了）
我們寫一個例子來研究一下：
public class HashMapIteratorDemo {
String[] arr = {"aa", "bb", "cc"};
public void test1() {
for(String str : arr) {
}
}
}將上面的例子轉(zhuǎn)為字節(jié)碼反編譯一下（主函數(shù)部分）：
也許我們不能很清楚這些指令到底有什么作用，但是我們可以對比一下下面段代碼產(chǎn)生的字節(jié)碼指令：
public class HashMapIteratorDemo2 {
String[] arr = {"aa", "bb", "cc"};
public void test1() {
for(int i = 0; i < arr.length; i++) {
String str = arr[i];
}
}
}
看看兩個字節(jié)碼文件，有木有發(fā)現(xiàn)指令幾乎相同，如果還有疑問我們再看看對集合的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();
}
}
}將兩個方法的字節(jié)碼對比如下：
我們發(fā)現(xiàn)兩個方法字節(jié)碼指令操作幾乎一模一樣；
這樣我們可以得出以下結(jié)論：
對集合來說，由于集合都實現(xiàn)了Iterator迭代器，foreach語法最終被編譯器轉(zhuǎn)為了對Iterator.next()的調(diào)用；
對于數(shù)組來說，就是轉(zhuǎn)化為對數(shù)組中的每一個元素的循環(huán)引用。
HashMap遍歷集合并對集合元素進行remove、put、add
1、現(xiàn)象
根據(jù)以上分析，我們知道HashMap底層是實現(xiàn)了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);
}
}
}執(zhí)行結(jié)果：
執(zhí)行沒有問題，put操作也成功了。
但是！但是！但是！問題來了?。?！
我們知道HashMap是一個線程不安全的集合類，如果使用foreach遍歷時，進行add，remove操作會java.util.ConcurrentModificationException異常。put操作可能會拋出該異常。（為什么說可能，這個我們后面解釋）
為什么會拋出這個異常呢？
我們先去看一下java api文檔對HasMap操作的解釋吧。
翻譯過來大致的意思就是該方法是返回此映射中包含的鍵的集合視圖。集合由映射支持，如果在對集合進行迭代時修改了映射（通過迭代器自己的移除操作除外），則迭代的結(jié)果是未定義的。集合支持元素移除，通過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);
}
}
}
執(zhí)行出現(xiàn)異常：
這就是驗證了上面說的put操作可能會拋出java.util.ConcurrentModificationException異常。
但是有疑問了，我們上面說過foreach循環(huán)就是通過迭代器進行的遍歷??？為什么到這里是不可以了呢？
這里其實很簡單，原因是我們的遍歷操作底層確實是通過迭代器進行的，但是我們的remove等操作是通過直接操作map進行的，如上例子：map.put(4, "AA");//這里實際還是直接對集合進行的操作，而不是通過迭代器進行操作。所以依然會存在ConcurrentModificationException異常問題。
2、細究底層原理
我們再去看看HashMap的源碼，通過源代碼，我們發(fā)現(xiàn)集合在使用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是表示期望的修改次數(shù)，在迭代器構造的時候這兩個值是相等，如果在遍歷過程中這兩個值出現(xiàn)了不同步就會拋出ConcurrentModificationException異常。
現(xiàn)在我們來看看集合remove操作：
（1）HashMap本身的remove實現(xiàn)：
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實現(xiàn)
public final boolean remove(Object key) {
return removeNode(hash(key), key, null, false, true) != null;
}（3）HashMap.EntrySet的remove實現(xiàn)
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方法實現(xiàn)
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進行同步
}以上四種方式都通過調(diào)用HashMap.removeNode方法來實現(xiàn)刪除key的操作。在removeNode方法內(nèi)只要移除了key， modCount就會執(zhí)行一次自增操作，此時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實現(xiàn)中，只有第三種iterator的remove方法在調(diào)用完removeNode方法后同步了expectedModCount值與modCount相同，所以在遍歷下個元素調(diào)用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();
}
}
}
}到此這篇關于Java map為什么不能遍歷的同時進行增刪操作的文章就介紹到這了,更多相關Java map 內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
Java?GUI實現(xiàn)學生成績管理系統(tǒng)
這篇文章主要為大家詳細介紹了Java?GUI實現(xiàn)學生成績管理系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-01-01
這篇文章主要介紹了java類和對象原理與用法,結(jié)合實例形式分析了java類和對象的相關概念、功能、原理、使用技巧與操作注意事項,需要的朋友可以參考下2020-02-02
Spring Security如何使用URL地址進行權限控制
這篇文章主要介紹了Spring Security如何使用URL地址進行權限控制,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-12-12
這篇文章主要介紹了IDEA如何配置本地tomcat啟動項目問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-12-12
Springboot實現(xiàn)根據(jù)用戶ID切換動態(tài)數(shù)據(jù)源
在很多具體應用場景中，我們需要用到動態(tài)數(shù)據(jù)源的情況，比如多租戶的場景，系統(tǒng)登錄時需要根據(jù)用戶信息切換到用戶對應的數(shù)據(jù)庫。這篇文章主要介紹了SpringBoot根據(jù)用戶ID實現(xiàn)切換動態(tài)數(shù)據(jù)源的示例代碼，感興趣的可以了解一下2021-12-12
在實際的業(yè)務開發(fā)的時候，常常會需要把相關的數(shù)據(jù)信息，通過一些技術手段生成對應的PDF文件，然后返回給用戶。本文將手把手教大家如何利用Java實現(xiàn)在線生成pdf文檔，需要的可以參考一下2022-03-03
這篇文章主要介紹了IDEA熱部署配置詳細教程,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-10-10
這篇文章主要為大家介紹了MyBatis中不建議使用where?1=1的原因詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-06-06
這篇文章主要介紹了java正則表達式處理花括號內(nèi)容替換賦值問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-05-05
這篇文章主要介紹了SpringBoot集成Shiro進行權限控制和管理的示例,小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-03-03