HashMap原理剖析

 1 package cn.yzx.hashmap;
 2 /**
 3  * 自定义的Map接口
 4  * @author Xuas
 5  *
 6  */
 7 public interface MyMap<K,V> {
 8     
 9     public V put(K k,V v);//将k v属性包装成对象存储到hash表中
10     
11     public V get(K k);//根据key获取value
12     
13     public int size();//获取hash表的长度
14     
15     /**
16      * 内部接口Entry<K,V>
17      *         Entry对象就是存储到hash表中的数据对象
18      *         hash表中每个元素存储的数据结构是一个Entry对象（包括key,value,next指针三个属性）
19      */
20     public interface Entry<K,V> {
21         public K getKey();//获取key
22         public V getValue();//获取value
23     }
24 }

  1 package cn.yzx.hashmap;
  2 
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 
  6 public class MyHashMap<K,V> implements MyMap<K, V> {
  7 
  8     /**
  9      * hash表的默认长度
 10      * jdk中的static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
 11      */
 12     private static int defaultLength = 16;
 13     
 14     /**
 15      * 负载因子（阈值）
 16      * 当表中元素数量超过 表容量 * 负载因子，那么表长度就需要扩容。（预警作用）
 17      * static final float DEFAULT_LOAD_FACTOR = 0.75f;
 18      */
 19     private static double defaultLoader = 0.75;
 20     
 21     /**
 22      * 表中存储元素的个数
 23      */
 24     private int size = 0;
 25     
 26     /**
 27      * 存储数据的Entry[]
 28      */
 29     private Entry<K,V>[] table = null;
 30     
 31     /**
 32      * 构造初始化属性值
 33      * public HashMap(int initialCapacity, float loadFactor) {}
 34      * @param length
 35      * @param loader
 36      */
 37     public MyHashMap(int length,double loader) {
 38         defaultLength = length;
 39         defaultLoader = loader;
 40         table = new Entry[defaultLength];
 41     }
 42     
 43     /**
 44      * 无参构造使用默认值
 45      */
 46     public MyHashMap() {
 47         this(defaultLength, defaultLoader);
 48     }
 49     
 50     /**
 51      * 需要把k,v存储到hash表中
 52      */
 53     @Override
 54     public V put(K k, V v) {
 55         
 56         if(size >= defaultLength * defaultLoader) {//进行扩容
 57             up2size();
 58         }
 59         
 60         //01.获取表中索引
 61         int index = getIndex(k);
 62         //02.判断此index上是否存在数据
 63         Entry<K,V> entry = table[index];
 64         if(null == entry) {//为空进行填充entry数据
 65             table[index] = new Entry(k,v,null);//因entry==null,故next为null
 66             size++;
 67         }else {//此index上存在数据
 68             table[index] = newEntry(k,v,entry);//新entry覆盖此位置上的原entry，并将新entry的next指针指向原entry
 69             size++;
 70         }
 71         
 72         return table[index].getValue();
 73     }
 74     
 75     /**
 76      * 实例化Entry对象
 77      * @param k
 78      * @param v
 79      * @return
 80      */
 81     private Entry<K,V> newEntry(K k,V v,Entry<K,V> next) {
 82         return new Entry(k,v,next);
 83     }
 84     
 85     /**
 86      * 扩容：默认扩容是扩大一倍
 87      * 疑问：扩容后原表中的元素在新表中的位置会变化吗？
 88      * 一定会。因为表中索引index是通过hash算法得到的。即：除留余数法 key.hashCode() % table.length = index
 89      * 这个table.length已经变化了！（再散列过程，重新散列分配位置 计算新的索引index）
 90      */
 91     private void up2size() {
 92         Entry<K,V>[] newTable = new Entry[defaultLength * 2];
 93     }
 94     
 95     /**
 96      * 再散列（重新分配位置）
 97      * @param newTable
 98      */
 99     private void againHash(Entry<K,V>[] newTable) {
100         //01.获取原表中的数据
101         List<Entry<K,V>> list = new ArrayList<Entry<K,V>>();
102         
103         for(int i=0 ; i<table.length; i++) {
104             if(null == table[i]) {//此判断目的：不一定hash表中所有的元素都有数据（index：i是hash算法计算出来的）
105                 continue;
106             }
107             findEntryByNext(table[i], list);
108         }
109         
110         if(list.size() > 0) {
111             //重新初始化hash表属性
112             size = 0;
113             defaultLength = defaultLength * 2;
114             table = newTable;
115             
116             for(Entry<K,V> entry : list) {
117                 if(null != entry.next) {
118                     entry.next = null; //初始化next指针
119                 }
120                 put(entry.getKey(), entry.getValue());//将数据添加到扩容后的hash表中
121             }
122         }
123     }
124     
125     /**
126      * 因为hash表是链表结构，所以通过next递归将原表中元素添加到List集合中，以便后续存入新表中
127      * @param entry
128      * @param list
129      */
130     private void findEntryByNext(Entry<K,V> entry,List<Entry<K,V>> list) {
131         if(null != entry && null != entry.next) {
132             list.add(entry);
133             findEntryByNext(entry.next, list);
134         }else {
135             list.add(entry);
136         }
137     }
138     
139     /**
140      * 根据key使用hash算法返回hash表的索引index
141      * 根据key的hash值对hash表长度取模。得到index索引就是表中的存储位置
142      * @param k
143      * @return
144      */
145     private int getIndex(K k) {
146         int l = defaultLength;
147         
148         int index = k.hashCode() % l;
149         return index >= 0 ? index : -index;
150     }
151     
152     /**
153      * 根据key递归的去找key相等的value值
154      */
155     @Override
156     public V get(K k) {
157         
158         int index = getIndex(k);//获取索引
159         if(null == table[index]) {
160             return null;
161         }
162         return findValueByEqualKey(k, table[index]);
163     }
164     
165     /**
166      * 表中两个元素是同一个索引（同一个索引index下存在不同的key）
167      * 所以我们需要拿到参数传进来的key和index下与之对应的key相同的那个元素的value
168      * 使用递归实现
169      * @param k
170      * @param entry
171      * @return
172      */
173     private V findValueByEqualKey(K k,Entry<K,V> entry) {
174         if(k == entry.getKey() || k.equals(entry.getKey())) {
175             return entry.getValue();
176         }else {
177             if(null != entry.next) {
178                 return findValueByEqualKey(k, entry.next);
179             }
180         }
181         return null;
182     }
183 
184     @Override
185     public int size() {
186         // TODO Auto-generated method stub
187         return 0;
188     }
189     
190     /**
191      * 内部类实现Entry接口（因为Entry是接口无法实例化，此内部类目的是实例化Entry对象）
192      *  static class Node<K,V> implements Map.Entry<K,V> {}
193      * @author Xuas
194      *
195      * @param <K>
196      * @param <V>
197      */
198     class Entry<K,V> implements MyMap.Entry<K, V> {
199         
200         K k;
201         
202         V v;
203         
204         Entry<K,V> next;//next指针，next是指向Entry对象的
205         
206         public Entry(K k,V v,Entry<K,V> next) {
207             this.k = k;
208             this.v = v;
209             this.next = next;
210         }
211         
212         @Override
213         public K getKey() {
214             return k;
215         }
216 
217         @Override
218         public V getValue() {
219             return v;
220         }
221         
222     }
223 
224 }

 1 package cn.yzx.hashmap;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 
 6 public class Test {
 7     public static void main(String[] args) {
 8         // 测试jdk的HashMap
 9         Map<String, String> jdkmap = new HashMap<String, String>();
10 
11         Long begin = System.currentTimeMillis();
12         for (int i = 0; i < 1000; i++) {
13             jdkmap.put("key" + i, "value" + i);
14         }
15 
16         for (int i = 0; i < 1000; i++) {
17             System.out.println(jdkmap.get("key" + i));
18         }
19         Long end = System.currentTimeMillis();
20         System.out.println("jdk‘time:" + (end - begin));
21         
22         System.out.println("*************************************************************");
23         // 自定义的MyHashMap
24         MyMap<String, String> mymap = new MyHashMap<String, String>();
25 
26         Long begin2 = System.currentTimeMillis();
27         for (int i = 0; i < 1000; i++) {
28             mymap.put("key" + i, "value" + i);
29         }
30 
31         for (int i = 0; i < 1000; i++) {
32             System.out.println(mymap.get("key" + i));
33         }
34         Long end2 = System.currentTimeMillis();
35         System.out.println("jdk‘time:" + (end2 - begin2));
36 
37     }
38 }