About HashMap traversal, why should entry

EnumMap.entrySet () This method returns a Set <Map.Entry <K, V >>, Map.Entry the Map is an interface, he uses is a map entry (inside the Value and Key), and Set <Map.Entry <K, V >> Set represents a map entry. There Map.Entry corresponding getKey and getValue methods, namely JavaBean, so that we can remove the Key and Value from one item.

Below are four ways to traverse the Map:

 1 public static void main(String[] args) {
 2  
 3  
 4   Map<String, String> map = new HashMap<String, String>();
 5   map.put("1", "value1");
 6   map.put("2", "value2");
 7   map.put("3", "value3");
 8   
 9   //第一种：普遍使用，二次取值
10   System.out.println("通过Map.keySet遍历key和value：");
11   for (String key : map.keySet()) {
12    System.out.println("key= "+ key + " and value= " + map.get(key));
13   }
14    
15    // second 
16    System.out.println ( "traversal key and value by using Map.entrySet Iterator:" );
 . 17    the Iterator <of Map.Entry <String, String >> = IT . EnumMap.entrySet () Iterator ();
 18 is    the while (it.hasNext ()) {
 . 19     of Map.Entry <String, String> = entry it.next ();
 20 is     System.out.println ( "Key =" entry.getKey + () + "and = value "+ entry.getValue ());
 21 is    }
 22 is    
23 is    // third: recommended, especially when mass 
24    System.out.println (" key and traversing through Map.entrySet value " );
 25    for ( Map.Entry <String, String>entry: EnumMap.entrySet ()) {
 26 is     System.out.println ( "Key =" entry.getKey + () + "and value =" + entry.getValue ());
 27    }
 28   
29    // fourth 
30    System.out.println ( "pass through all value Map.values (), but not traversing Key" );
 31 is    for (String V: map.values ()) {
 32     System.out.println ( "value =" + V);
 33 is    }
 34 is   }

Below is the source code HashMap:

First, when the underlying HashMap implementation with an array of Entry

 1 java] view plain copy
 2 <pre name="code" class="java">  /** 
 3      * The table, resized as necessary. Length MUST Always be a power of two. 
 4      */  
 5     transient Entry[] table; //声明了一个数组  
 6    ........  
 7    public HashMap() {  
 8         this.loadFactor = DEFAULT_LOAD_FACTOR;  
 9         threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);  
10         table = new Entry[DEFAULT_INITIAL_CAPACITY];//Initializing the array size is DEFAULT_INITIAL_CAPACITY (here 16)   
. 11          the init ();  
 12 is      } </ pre> <br>

Then look at the Entry in any place is defined, the source continued, we found that 674 lines of source code HashMap its definition, that he is an internal HashMap class, and implements the interface Map.Entry,

 1 static class Entry<K,V> implements Map.Entry<K,V> {  
 2     final K key;  
 3     V value;  
 4     Entry<K,V> next;  
 5     final int hash;  
 6   
 7     /** 
 8      * Creates new entry. 
 9      */  
10     Entry(int h, K k, V v, Entry<K,V> n) {  
11         value = v;  
12         next = n;  
13         key = k;  
14         hash = h;  
15     }  
16   
17     public final K getKey() {  
18         return key;  
19     }  
20   
21     public final V getValue() {  
22         return value;  
23     }  
24   
25     public final V setValue(V newValue) {  
26  V oldValue = value;  
27         value = newValue;  
28         return oldValue;  
29     }  
30   
31     public final boolean equals(Object o) {  
32         if (!(o instanceof Map.Entry))  
33             return false;  
34         Map.Entry e = (Map.Entry)o;  
35         Object k1 = getKey();  
36         Object k2 = e.getKey();  
37         if (k1 == k2 || (k1 != null && k1.equals(k2))) {  
38             Object v1 = getValue();  
39             Object v2 = e.getValue();  
40             if (v1 == v2 || (v1 != null && v1.equals(v2)))  
41                 return true;  
42         }  
43         return false;  
44     }  
45   
46     public final int hashCode() {  
47         return (key==null   ? 0 : key.hashCode()) ^  
48                (value==null ? 0 : value.hashCode());  
49     }  
50   
51     public final String toString() {  
52         return getKey() + "=" + getValue();  
53     }  
54   
55     /** 
56      * This method is invoked whenever the value in an entry is 
57      * overwritten by an invocation of put(k,v) for a key k that's already 
58      * in the HashMap. 
59      */  
60     void recordAccess(HashMap<K,V> m) {  
61     }  
62   
63     /** 
64      * This method is invoked whenever the entry is 
65      * removed from the table. 
66      */  
67     void recordRemoval(HashMap<K,V> m) {  
68     }  
69 }

　　If so then let's look at how Map.Entry This interface is defined, that he is a Map of an internal interface and defines some method

 1   interface Entry<K,V> {  
 2     /** 
 3  * Returns the key corresponding to this entry. 
 4  * 
 5  * @return the key corresponding to this entry 
 6         * @throws IllegalStateException implementations may, but are not 
 7         *         required to, throw this exception if the entry has been 
 8         *         removed from the backing map. 
 9  */  
10 K getKey();  
11   
12     /** 
13  * Returns the value corresponding to this entry.  If the mapping 
14  * has been removed from the backing map (by the iterator's 
15  * <tt>remove</tt> operation), the results of this call are undefined. 
16  * 
17  * @return the value corresponding to this entry 
18         * @throws IllegalStateException implementations may, but are not 
19         *         required to, throw this exception if the entry has been 
20         *         removed from the backing map. 
21  */  
22 V getValue();  
23   
24     /** 
25  * Replaces the value corresponding to this entry with the specified 
26  * value (optional operation).  (Writes through to the map.)  The 
27  * behavior of this call is undefined if the mapping has already been 
28  * removed from the map (by the iterator's <tt>remove</tt> operation). 
29  * 
30         * @param value new value to be stored in this entry 
31         * @return old value corresponding to the entry 
32         * @throws UnsupportedOperationException if the <tt>put</tt> operation 
33         *         is not supported by the backing map 
34         * @throws ClassCastException if the class of the specified value 
35         *         prevents it from being stored in the backing map 
36         * @throws NullPointerException if the backing map does not permit 
37         *         null values, and the specified value is null 
38         * @throws IllegalArgumentException if some property of this value 
39         *         prevents it from being stored in the backing map 
40         * @throws IllegalStateException implementations may, but are not 
41         *         required to, throw this exception if the entry has been 
42         *         removed from the backing map. 
43         */  
44 V setValue(V value);  
45   
46 /** 
47  * Compares the specified object with this entry for equality. 
48  * Returns <tt>true</tt> if the given object is also a map entry and 
49  * the two entries represent the same mapping.  More formally, two 
50  * entries <tt>e1</tt> and <tt>e2</tt> represent the same mapping 
51  * if<pre> 
52         *     (e1.getKey()==null ? 
53         *      e2.getKey()==null : e1.getKey().equals(e2.getKey()))  && 
54         *     (e1.getValue()==null ? 
55         *      e2.getValue()==null : e1.getValue().equals(e2.getValue())) 
56         * </pre> 
57  * This ensures that the <tt>equals</tt> method works properly across 
58  * different implementations of the <tt>Map.Entry</tt> interface. 
59  * 
60  * @param o object to be compared for equality with this map entry 
61  * @return <tt>true</tt> if the specified object is equal to this map 
62  *         entry 
63         */  
64 boolean equals(Object o);  
65   
66 /** 
67  * Returns the hash code value for this map entry.  The hash code 
68  * of a map entry <tt>e</tt> is defined to be: <pre> 
69  *     (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^ 
70  *     (e.getValue()==null ? 0 : e.getValue().hashCode()) 
71         * </pre> 
72  * This ensures that <tt>e1.equals(e2)</tt> implies that 
73  * <tt>e1.hashCode()==e2.hashCode()</tt> for any two Entries 
74  * <tt>e1</tt> and <tt>e2</tt>, as required by the general 
75  * contract of <tt>Object.hashCode</tt>. 
76  * 
77  * @return the hash code value for this map entry 
78  * @see Object#hashCode() 
79  * @see Object#equals(Object) 
80  * @see #equals(Object) 
81  */  
82 int hashCode();  
83    }

　　Before the return pass, why HashMap Why choose Entry array to store key-value?

　　Entry implemented as an interface which defines the Map.Entry getKey (), getValue (), setKey (), setValue () corresponds to a javaBean the like, of a key-value pairs to facilitate the subsequent operation of the package, from here we actually not only can think of a HashMap, such as LinkedHashMap, TreeMap and other inherited from the map storage container for key-value should be used only organization in the form of Entry Entry is not the same, HashMap plus an array using a linked list, LinkedHashMap with is in the form of a linked list, a binary tree TreeMap should be used.

　　keySet () method returns the value of the Map is set key value; the entrySet () returns a return value is set Set, this type of set is Map.Entry.

　　Therefore, to walk HashMap There are four ways to begin with, not difficult to understand why have keySet (), values (), iterator () still have to use the Entry.

Over...

reference:

About HashMap traversal, why should entry

Guess you like