Java中HashMap的实现原理

 1 package org.arpit.javapostsforlearning;
 2 public class Country {
 3  
 4  String name;
 5  long population;
 6  
 7  public Country(String name, long population) {
 8   super();
 9   this.name = name;
10   this.population = population;
11  }
12  public String getName() {
13   return name;
14  }
15  public void setName(String name) {
16   this.name = name;
17  }
18  public long getPopulation() {
19   return population;
20  }
21  public void setPopulation(long population) {
22   this.population = population;
23  }
24  
25  // If length of name in country object is even then return 31(any random number) and if odd then return 95(any random number).
26  // This is not a good practice to generate hashcode as below method but I am doing so to give better and easy understanding of hashmap.
27  @Override
28  public int hashCode() {
29   if(this.name.length()%2==0)
30    return 31;
31   else
32    return 95;
33  }
34  @Override
35  public boolean equals(Object obj) {
36  
37   Country other = (Country) obj;
38    if (name.equalsIgnoreCase((other.name)))
39    return true;
40   return false;
41  }
42  
43 }

 1 import java.util.HashMap;
 2 import java.util.Iterator;
 3    
 4 public class HashMapStructure {
 5    
 6     /**
 7      * @author Arpit Mandliya
 8      */
 9     public static void main(String[] args) {
10            
11         Country india=new Country("India",1000);
12         Country japan=new Country("Japan",10000);
13            
14         Country france=new Country("France",2000);
15         Country russia=new Country("Russia",20000);
16            
17         HashMap<country,string> countryCapitalMap=new HashMap<country,string>();
18         countryCapitalMap.put(india,"Delhi");
19         countryCapitalMap.put(japan,"Tokyo");
20         countryCapitalMap.put(france,"Paris");
21         countryCapitalMap.put(russia,"Moscow");
22            
23         Iterator<country> countryCapitalIter=countryCapitalMap.keySet().iterator();//put debug point at this line
24         while(countryCapitalIter.hasNext())
25         {
26             Country countryObj=countryCapitalIter.next();
27             String capital=countryCapitalMap.get(countryObj);
28             System.out.println(countryObj.getName()+"----"+capital);
29             }
30         }
31    
32    
33 } 

1 static class Entry implements Map.Entry
2 {
3         final K key;
4         V value;
5         Entry next;
6         final int hash;
7         ...//More code goes here
8 }   `

 1 /**
 2   * Associates the specified value with the specified key in this map. If the
 3   * map previously contained a mapping for the key, the old value is
 4   * replaced.
 5   *
 6   * @param key
 7   *            key with which the specified value is to be associated
 8   * @param value
 9   *            value to be associated with the specified key
10   * @return the previous value associated with <tt>key</tt>, or <tt>null</tt>
11   *         if there was no mapping for <tt>key</tt>. (A <tt>null</tt> return
12   *         can also indicate that the map previously associated
13   *         <tt>null</tt> with <tt>key</tt>.)
14   */
15  public V put(K key, V value) {
16   if (key == null)
17    return putForNullKey(value);
18   int hash = hash(key.hashCode());
19   int i = indexFor(hash, table.length);
20   for (Entry<k , V> e = table[i]; e != null; e = e.next) {
21    Object k;
22    if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
23     V oldValue = e.value;
24     e.value = value;
25     e.recordAccess(this);
26     return oldValue;
27    }
28   }
29  
30   modCount++;
31   addEntry(hash, key, value, i);
32   return null;
33  }

 1 /**
 2   * Returns the value to which the specified key is mapped, or {@code null}
 3   * if this map contains no mapping for the key.
 4   *
 5   * <p>
 6   * More formally, if this map contains a mapping from a key {@code k} to a
 7   * value {@code v} such that {@code (key==null ? k==null :
 8   * key.equals(k))}, then this method returns {@code v}; otherwise it returns
 9   * {@code null}. (There can be at most one such mapping.)
10   *
11   * </p><p>
12   * A return value of {@code null} does not <i>necessarily</i> indicate that
13   * the map contains no mapping for the key; it‘s also possible that the map
14   * explicitly maps the key to {@code null}. The {@link #containsKey
15   * containsKey} operation may be used to distinguish these two cases.
16   *
17   * @see #put(Object, Object)
18   */
19  public V get(Object key) {
20   if (key == null)
21    return getForNullKey();
22   int hash = hash(key.hashCode());
23   for (Entry<k , V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
24    Object k;
25    if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
26     return e.value;
27   }
28   return null;
29  }