दिलचस्प पोस्ट
लिस्प निष्पादनीय रेंडरएक्शन रेंडरपर्टीअल जावा दो सूचियों की तुलना करें जोड़ें एस्यूब्यूव्यू एनीमेशन Libxml2 और संबद्ध अजगर बाइंडिंग – विंडोज़ को स्थापित करें क्या ए == 0 वास्तव में ~ ए से बेहतर है? प्रतिबिंब का उपयोग कर तर्क नाम कैसे प्राप्त करें ग्रिडबैग लेआउट का उपयोग करते समय एनिमेशन क्या आप एक शुद्ध टेम्पलेट इंजन की सिफारिश कर सकते हैं? कैसे MySQL के आदेश द्वारा रैंड () काम करता है? जावास्क्रिप्ट चर का उपयोग करने के लिए एक स्ट्रिंग का उपयोग करने का एक तरीका है जिसमें वेरिएबल का नाम है? कैसे पहलू अनुपात के संरक्षण के लिए स्क्रीन भर में तीन छवियों खिंचाव? कैसे favicon.ico अनुरोधों को रोकने के लिए? क्या अप्रयुक्त सीएसएस छवियों को डाउनलोड किया गया है? क्रॉस-ब्राउज़र जावास्क्रिप्ट XML पार्सिंग

किसी नक्शे से फिर से चलना और हटाना

मैं कर रहा था:

for (Object key : map.keySet()) if (something) map.remove(key); 

जिसने एक समवर्ती सुधार को छोड़ दिया, इसलिए मैंने उसे इसमें बदल दिया:

 for (Object key : new ArrayList<Object>(map.keySet())) if (something) map.remove(key); 

यह, और नक्शे को संशोधित करने वाली कोई अन्य प्रक्रिया सिंक्रनाइज़ किए गए ब्लॉक में हैं

क्या कोई बेहतर समाधान है?

यदि कोई भी बेहतर समाधान के साथ नहीं आता है, तो पहले कहने पर कोई टिक नहीं हो सकता;)

Solutions Collecting From Web of "किसी नक्शे से फिर से चलना और हटाना"

प्रविष्टि को निकालने के लिए लूप में इटरेटर का उपयोग करने के लिए यहां एक कोड नमूना है।

  Map<String, String> map = new HashMap<String, String>() { { put("test", "test123"); put("test2", "test456"); } }; for(Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); it.hasNext(); ) { Map.Entry<String, String> entry = it.next(); if(entry.getKey().equals("test")) { it.remove(); } } 

जावा 1.8 के रूप में आप यह लैम्ब्डा भाव और धाराओं का उपयोग करके कर सकते हैं:

 map.entrySet().removeIf(e-> <boolean expression> ); 

एक वास्तविक इटरेटर का उपयोग करें

 Iterator<Object> it = map.keySet().iterator(); while (it.hasNext()) { it.next(); if (something) it.remove(); } 

दरअसल, आपको उस काम को बनाने के लिए entrySet() बजाय entrySet() पर फिर से entrySet() पड़ सकता है

क्या कोई बेहतर समाधान है?

ठीक है, निश्चित रूप से, एक ही बयान में ऐसा करने का एक बेहतर तरीका है, लेकिन यह उस शर्त पर निर्भर करता है जो तत्वों को हटा दिया जाता है।

उदाहरण के लिए: उन सभी तत्वों को हटा दें जहां value का परीक्षण है , फिर नीचे का उपयोग करें:

 map.values().removeAll(Collections.singleton("test")); 

अद्यतन यह जावा 8 में लैम्ब्डा अभिव्यक्ति का उपयोग कर एक पंक्ति में किया जा सकता है

 map.entrySet().removeIf(e-> <boolean expression> ); 

मुझे पता है कि यह सवाल बहुत पुराना है, लेकिन चीजें करने के लिए बेहतर तरीके से अद्यतन करने में कोई नुकसान नहीं है 🙂

ConcurrentHashMap

आप java.util.concurrent.ConcurrentHashMap उपयोग कर सकते हैं।

यह ConcurrentMap Map लागू करता है (जो Map इंटरफ़ेस फैली हुई है)।

उदाहरण :

 Map<Object, Content> map = new ConcurrentHashMap<Object, Content>(); for (Object key : map.keySet()) { if (something) { map.remove(key); } } 

यह दृष्टिकोण आपके कोड को अछूता छोड़ देता है केवल map प्रकार अलग है।

जावा 8 की पुनरावृत्ति के लिए एक अधिक घोषणात्मक दृष्टिकोण का समर्थन करता है, इसके साथ हम इसे गणना करने के बजाय हम चाहते हैं कि परिणाम को निर्दिष्ट करें। नए दृष्टिकोण के लाभ यह है कि यह और अधिक पठनीय, कम त्रुटि प्रवण हो सकता है।

 public static void mapRemove() { Map<Integer, String> map = new HashMap<Integer, String>() { { put(1, "one"); put(2, "two"); put(3, "three"); } }; map.forEach( (key, value) -> { System.out.println( "Key: " + key + "\t" + " Value: " + value ); }); map.keySet().removeIf(e->(e>2)); System.out.println("After removing element"); map.forEach( (key, value) -> { System.out.println( "Key: " + key + "\t" + " Value: " + value ); }); } 

और परिणाम निम्नानुसार है:

 Key: 1 Value: one Key: 2 Value: two Key: 3 Value: three After removing element Key: 1 Value: one Key: 2 Value: two 

नक्शे को ढकाकर तत्वों को सुरक्षित रूप से निकालने के लिए आपको Iterator का उपयोग करना होगा।

मैं पॉल टॉम्ब्लिन से सहमत हूं मैं आमतौर पर कीसेट के इटरेटर का उपयोग करता हूं, और फिर उस स्थिति के लिए मेरी स्थिति को बंद कर देता हूं:

 Iterator<Integer> it = map.keySet().iterator(); while(it.hasNext()) { Integer key = it.next(); Object val = map.get(key); if (val.shouldBeRemoved()) { it.remove(); } } 

हो सकता है कि आप एक अलग संग्रह में उन्हें निकालने और संग्रहीत करने के लिए कुंजी की तलाश में मानचित्र पर फिर से दोहरा सकें। फिर नक्शे से कुंजियों का संग्रह हटा दें। नक्शा संशोधित करते समय दोबारा यात्रा पर आम तौर पर मूसलाया जाता है। यह विचार संदेह हो सकता है कि यदि नक्शा बहुत बड़ा है।

एक वैकल्पिक, अधिक वर्बोज़ मार्ग

 List<SomeObject> toRemove = new ArrayList<SomeObject>(); for (SomeObject key: map.keySet()) { if (something) { toRemove.add(key); } } for (SomeObject key: toRemove) { map.remove(key); } 

और ये भी काम करना चाहिए ..

 running is ConcurrentMap<Integer, String> Set<Entry<Integer, String>> set = running.entrySet(); for (Entry<Integer, String> entry : set ) { if (entry.getKey()>600000) { set.remove(entry); } } 
  Set s=map.entrySet(); Iterator iter = s.iterator(); while (iter.hasNext()) { Map.Entry entry =(Map.Entry)iter.next(); if("value you need to remove".equals(entry.getKey())) { map.remove(); } }