{"id":1586,"date":"2017-03-22T13:16:46","date_gmt":"2017-03-22T07:46:46","guid":{"rendered":"https:\/\/www.wikitechy.com\/technology\/?p=1586"},"modified":"2017-03-29T10:09:39","modified_gmt":"2017-03-29T04:39:39","slug":"java-efficiently-iterate-entry-map","status":"publish","type":"post","link":"https:\/\/www.wikitechy.com\/technology\/java-efficiently-iterate-entry-map\/","title":{"rendered":"JAVA – How to efficiently iterate over each Entry in a Map"},"content":{"rendered":"

Java Map Interface<\/b><\/span><\/h4>\n
    \n
  • A map contains values on the basis of key i.e. key and value pair. Each key and value pair is known as an entry. Map contains only unique keys.<\/li>\n
  • Map is useful if we have to search, update or delete elements on the basis of key.<\/li>\n<\/ul>\n

    Map.Entry<\/b> Interface<\/b><\/span><\/h4>\n
      \n
    • Entry is the sub interface of Map.<\/li>\n
    • So we will be accessed it by Map.Entry name.<\/li>\n
    • It provides methods to get key and value.<\/li>\n<\/ul>\n

      How to Iterate Over a Map in Java<\/b><\/span><\/h4>\n
        \n
      • There are several ways of iterating over a Map in Java.<\/li>\n
      • Since all maps in Java implement Map interface, following techniques will work for any map implementation (HashMap, TreeMap, LinkedHashMap, Hashtable, etc.)<\/li>\n<\/ul>\n
          \n
            \n
          • Iterating over entries using For-Each loop.<\/b><\/li>\n
          • Iterating over keys or values using For-Each loop.<\/b><\/li>\n
          • Iterating using Iterator.<\/b><\/li>\n
          • Iterating over keys and searching for values (inefficient).<\/b><\/li>\n<\/ul>\n<\/ul>\n

            Method 1: Iterating over entries using For-Each loop.<\/b><\/span><\/h4>\n
              \n
            • This is the most common method and is preferable in most cases.<\/li>\n
            • It should be used if we need both map keys and values in the loop.<\/li>\n<\/ul>\n
              java code<\/span> <\/div> 
              Map<Integer, Integer> map = new HashMap<Integer, Integer>();for (Map.Entry<Integer, Integer> entry : map.entrySet()) {    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());}<\/code><\/pre> <\/div>\n
              Note:<\/b><\/span><\/h4>\n
                \n
              • For-Each loop was introduced in Java 5, so this method is working only in newer versions of the language.<\/span><\/li>\n
              • In addition For-Each loop will throw NullPointerException if we try to iterate over a map that is null, so before iterating we should always check for null references.<\/span><\/li>\n<\/ul>\n
                Method 2: Iterating over keys or values using For-Each loop.<\/b><\/span><\/h4>\n
                 
                 java code<\/span> <\/div> 
                Map<Integer, Integer> map = new HashMap<Integer, Integer>();\/\/iterating over keys onlyfor (Integer key : map.keySet()) {    System.out.println("Key = " + key);}\/\/iterating over values onlyfor (Integer value : map.values()) {    System.out.println("Value = " + value);}<\/code><\/pre> <\/div>\n[ad type=”banner”]\n
                  \n
                • If we need only keys or values from the map, we can iterate over keySet or values instead of entrySet.<\/li>\n
                • This method gives a slight performance advantage over entrySet iteration (about 10% faster).<\/li>\n<\/ul>\n
                  Method 3: Iterating using Iterator.<\/b><\/span><\/h4>\n
                  Using Generics:<\/span><\/h4>\n
                   
                   java code<\/span> <\/div> 
                  Map<Integer, Integer> map = new HashMap<Integer, Integer>();Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();while (entries.hasNext()) {    Map.Entry<Integer, Integer> entry = entries.next();    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());}<\/code><\/pre> <\/div>\n
                  Without Generics:<\/span><\/h4>\n
                   
                   java code<\/span> <\/div> 
                  Map map = new HashMap();Iterator entries = map.entrySet().iterator();while (entries.hasNext()) {    Map.Entry entry = (Map.Entry) entries.next();    Integer key = (Integer)entry.getKey();    Integer value = (Integer)entry.getValue();    System.out.println("Key = " + key + ", Value = " + value);}<\/code><\/pre> <\/div>\n
                    \n
                  • Initially, it is the only way to iterate over a map in older versions of Java.<\/li>\n
                  • The other important feature is that it is the only method that allows to remove entries from the map during iteration by calling iterator.remove().<\/li>\n
                  • If we try to do this during For-Each iteration we will get “unpredictable results” according to Javadoc.<\/li>\n
                  • From a performance point of view this method is equal to a For-Each iteration.<\/li>\n<\/ul>\n
                    Method 4: Iterating over keys and searching for values (inefficient).<\/b><\/span><\/h4>\n
                     
                     java code<\/span> <\/div> 
                    Map<Integer, Integer> map = new HashMap<Integer, Integer>();for (Integer key : map.keySet()) {    Integer value = map.get(key);    System.out.println("Key = " + key + ", Value = " + value);}<\/code><\/pre> <\/div>\n
                      \n
                    • This might look like a cleaner alternative for method 1, but in practice it is slow and inefficient as getting values by a key might be time-consuming.<\/li>\n
                    • \u00a0If we have FindBugs installed, it will detect this and warn about inefficient iteration.<\/li>\n<\/ul>\n
                      Best way to Iterate over <\/b>HashMap<\/b> in Java<\/b><\/span><\/h4>\n
                        \n
                      • Here is the code example of Iterating over any Map class in Java (e.g. Hashtable or LinkedHashMap)<\/li>\n
                      • we used HashMap for iteration purpose, we can apply same technique to other Map implementations.<\/li>\n
                      • Since we are only using methods from java.uti.Map interface, solution is extensible to all kinds of Map in Java.<\/li>\n
                      • We will use Java 1.5 foreach loop and Iterating over each Map.Entry object, which we get by calling Map.entrySet() method.<\/li>\n
                      • Using Generics to avoid type casting.<\/li>\n<\/ul>\n
                         
                         java code<\/span> <\/div> 
                        for(Map.Entry<Integer, String> entry : map.entrySet()){ System.out.printf("Key : %s and Value: %s %n", entry.getKey(), entry.getValue()); }<\/code><\/pre> <\/div>\n[ad type=”banner”]\n
                          \n
                        • This above code has one drawback, we can not remove entries without risking ConcurrentModificationException.<\/li>\n<\/ul>\n
                          Removing Entries from Map in Java: <\/b><\/span><\/h4>\n
                            \n
                          • One reason for iterating over Map is removing selected key value pairs from Map.<\/li>\n
                          • This is a general Map requirement and holds true for any kind of Map e.g. HashMap, Hashtable, LinkedHashMap or even relatively new ConcurrentHashMap.<\/li>\n
                          • When we use foreach loop, it internally translated into Iterator code, but without explicit handle to Iterator, we just can not remove entries during Iteration. If you do,\u00a0 your Iterator may throw ConcurrentModificationException.<\/li>\n
                          • To avoid this, we need to use explicit Iterator and while loop for traversal. We will still use entrySet() for performance reason, but we will use Iterator’s remove() method for deleting entries from Map.<\/li>\n<\/ul>\n
                            Here code example\u00a0 to remove key values from HashMap in Java:<\/strong><\/p>\n
                             
                             java code<\/span> <\/div> 
                            Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();while(iterator.hasNext()){   Map.Entry<Integer, String> entry = iterator.next();   System.out.printf("Key : %s and Value: %s %n", entry.getKey(), entry.getValue());   iterator.remove(); \/\/ right way to remove entries from Map,                       \/\/ avoids ConcurrentModificationException}<\/code><\/pre> <\/div>\n
                            we are using\u00a0remove()<\/strong>\u00a0method from Iterator and not from\u00a0java.util.Map<\/strong>, which accepts a key object. This code is safe from\u00a0ConcurrentModificationException.<\/strong><\/p>\n
                            Removing Entries from Map in Java: <\/b><\/span><\/h4>\n
                              \n
                            • One reason for iterating over Map is removing selected key value pairs from Map.<\/li>\n
                            • This is a general Map requirement and holds true for any kind of Map (e.g. HashMap, Hashtable, LinkedHashMap or even relatively new ConcurrentHashMap)<\/li>\n
                            • When we use foreach loop, it internally translated into Iterator code, but without explicit handle to Iterator, we just can not remove entries during Iteration. If we do,\u00a0 our Iterator may throw ConcurrentModificationException.<\/li>\n
                            • To avoid this, we need to use explicit Iterator and while loop for traversal. We will still use entrySet() for performance reason, but we will use Iterator’s remove() method for deleting entries from Map.<\/li>\n<\/ul>\n
                              HashMap<\/b> Iterator Example<\/b><\/span><\/h4>\n
                              Here is complete code example, combining both approaches for iterating over HashMap in Java.<\/p>\n
                               
                               java code<\/span> <\/div> 
                              import java.util.HashMap;import java.util.Iterator; import java.util.Map; \/** * Best way to iterate over Map in Java, including any implementation e.g. * HashMap, TreeMap, LinkedHashMap, ConcurrentHashMap and Hashtable. * Java 1.5 foreach loop is most elegant and combined with entry set also * gives best performance, but not suitable for removing entries, as you don't have * reference to internal Iterator. * * Only way to remove entries from Map without throwing ConcurrentModificationException * is to use Iterator and while loop. * *\/public class WikitechyHashMapIteratorExample {    public static void main(String args[]) {             \/\/ Initializing HashMap with some key values        Map<Integer, String> map = new HashMap<Integer, String>();        map.put(1, "Core Java");        map.put(2, "Java SE");        map.put(3, "Java ME");        map.put(4, "Java EE");        map.put(5, "Java FX");               \/\/ Iterate over HashMap using foreach loop        System.out.println("Java 1.5 foreach loop provides most elegant                             way to iterate over HashMap in Java");        for(Map.Entry<Integer, String> entry : map.entrySet()){            System.out.printf("Key : %s and Value: %s %n", entry.getKey(),                                                           entry.getValue());        }\/\/ Better way to loop over HashMap, if you want to remove entry        System.out.println("Use Iterator and while loop, if you want                               to remove entries from HashMap during iteration");        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();        while(iterator.hasNext()){            Map.Entry<Integer, String> entry = iterator.next();            System.out.printf("Key : %s and Value: %s %n", entry.getKey(),                                                            entry.getValue());            iterator.remove(); \/\/ right way to remove entries from Map,                                \/\/ avoids ConcurrentModificationException        }    }      }<\/code><\/pre> <\/div>\n
                              Output:<\/b><\/span><\/h4>\n
                              Java 1.5 foreach loop provides most elegant way to iterate over HashMap in Java<\/strong><\/p>\n
                              Key : 1 and Value: Core Java<\/strong><\/p>\n
                              Key : 2 and Value: Java SE<\/strong><\/p>\n
                              Key : 3 and Value: Java ME<\/strong><\/p>\n
                              Key : 4 and Value: Java EE<\/strong><\/p>\n
                              Key : 5 and Value: Java FX<\/strong><\/p>\n
                              Use Iterator and while loop, if you want to remove entries from HashMap during iteration<\/strong><\/p>\n
                              Key : 1 and Value: Core Java<\/strong><\/p>\n
                              Key : 2 and Value: Java SE<\/strong><\/p>\n
                              Key : 3 and Value: Java ME<\/strong><\/p>\n
                              Key : 4 and Value: Java EE<\/strong><\/p>\n
                              Key : 5 and Value: Java FX<\/strong><\/p><\/blockquote>\n[ad type=”banner”]\n","protected":false},"excerpt":{"rendered":"
                              Java Map Interface A map contains values on the basis of key i.e. key and value pair. Each key and value pair is known as an entry. Map contains only unique keys. Map is useful if we have to search, update or delete elements on the basis of key. Map.Entry Interface Entry is the sub […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2139],"tags":[3232,3230,2671,2861,3223,3231,3221,3225,3220,2858,3224,2859,3229,2863,3219,3226,3218,3227,2866,3222,3228],"class_list":["post-1586","post","type-post","status-publish","format-standard","hentry","category-java","tag-4-different-ways-to-iterate-through-a-map-in-java","tag-efficiently-iterating-over-dictionary-list-values-by-skipping-missing-values-python-3","tag-for-each-over-an-array-in-javascript","tag-hashmap-entryset","tag-how-can-i-initialise-a-static-map","tag-how-do-you-iterate-over-a-hash-map-of-arraylists-of-string","tag-how-to-iterate-set-in-java","tag-how-to-loop-through-a-c-map-of-maps","tag-iterate-list-in-java","tag-iterate-through-map-c","tag-iterating-over-dictionaries-using-for-loops-in-python","tag-java-8-iterate-map","tag-java-efficient-iterating-over-char","tag-java-map-entryset","tag-java-map-iterator-remove","tag-java-most-efficient-method-to-iterate-over-all-elements-in-a-org-w3c-dom-document","tag-map-foreach-java","tag-skip-items-while-iterating-over-a-long-list","tag-ways-to-iterate-over-a-list-in-java","tag-what-is-the-best-way-to-iterate-over-a-dictionary-in-c","tag-whats-more-efficient"],"_links":{"self":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts\/1586","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/comments?post=1586"}],"version-history":[{"count":0,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts\/1586\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/media?parent=1586"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/categories?post=1586"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/tags?post=1586"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}