大话Java中的哈希(hash)结构（一）

 1 /*** 1. 构造方法：最终使用的是这个构造方法 ***/
 2 // 初始容量initialCapacity为16，装填因子loadFactor为0.75
 3 public HashMap(int initialCapacity, float loadFactor) {
 4     if (initialCapacity < 0)
 5         throw new IllegalArgumentException("Illegal initial capacity: " +
 6                                            initialCapacity);
 7     if (initialCapacity > MAXIMUM_CAPACITY)
 8         initialCapacity = MAXIMUM_CAPACITY;
 9     if (loadFactor <= 0 || Float.isNaN(loadFactor))
10         throw new IllegalArgumentException("Illegal load factor: " +
11                                            loadFactor);
12 
13     this.loadFactor = loadFactor;
14     threshold = initialCapacity;
15     init();//init可以忽略，方法默认为空{}，当你需要集成HashMap实现自己的类型时可以重写此方法做一些事
16 }
17 
18 /*** 2. (静态/实例)成员变量 ***/
19 /** 默认的容量，容量必须是2的幂 */
20 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
21 /** 最大容量2的30次方 */
22 static final int MAXIMUM_CAPACITY = 1 << 30;
23 /** 默认装填因子0.75 */
24 static final float DEFAULT_LOAD_FACTOR = 0.75f;
25 /** 默认Entry数组 */
26 static final Entry<?,?>[] EMPTY_TABLE = {};
27 
28 /** Entry数组：table */
29 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
30 
31 /** table中实际的Entry数量 */
32 transient int size;
33 
34 /** 
35  * size到达此门槛后，必须扩容table；
36  * 值为capacity * load factor，默认为16 * 0.75 也就是12。
37  * 意味着默认情况构造情况下，当你存够12个时，table会第一次扩容
38  */
39 int threshold;
40 
41 /** 装填因子，值从一开构造HashMap时就被确定了，默认为0.75 */
42 final float loadFactor;
43 
44 /**
45  * 哈希种子，实例化HashMap后在将要使用前设置的随机值，可以使得key的hashCode冲突更难出现
46  */
47 transient int hashSeed = 0;
48 
49 /**
50  * The number of times this HashMap has been structurally modified
51  * Structural modifications are those that change the number of mappings in
52  * the HashMap or otherwise modify its internal structure (e.g.,
53  * rehash).  This field is used to make iterators on Collection-views of
54  * the HashMap fail-fast.  (See ConcurrentModificationException).
55  */
56 transient int modCount;
57 
58 /*** 3. Map.Entry<K,V>：数组table中实际存储的类型 ***/
59 static class Entry<K,V> implements Map.Entry<K,V> {
60     final K key;       // "Key-Value对"的Key
61     V value;           // "Key-Value对"的Value
62     Entry<K,V> next;    
63     int hash;
64 
65     Entry(int h, K k, V v, Entry<K,V> n) {
66         value = v;
67         next = n;//链表的下一个Entry
68         key = k;
69         hash = h;
70     }
71     public final int hashCode() {
72         return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
73     }
74 }

 1 /** 存放 **/
 2 public V put(K key, V value) {
 3     if (table == EMPTY_TABLE) {
 4         inflateTable(threshold);//table会被初始化为长度16，且hashSeed会被赋值；
 5     }
 6     if (key == null)
 7         //HashMap允许key为null：在table中找到null key，然后设置Value，同时其hash为0；
 8         return putForNullKey(value);
 9 
10     // a). 计算key的hashCode，下面详细说
11     int hash = hash(key);
12 
13     // b). 根据hashCode计算index
14     int i = indexFor(hash, table.length);
15 
16     // c). 覆盖（如是相同Key则覆盖Value，注意这里不是解决冲突）：
17     // 遍历index位置的Entry链表，如果链表中Entry的hash相等且== || equals则认为是同一个key，所以覆盖value
18     for (Entry<K,V> e = table[i]; e != null; e = e.next) {
19         Object k;
20         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
21             V oldValue = e.value;
22             e.value = value;
23             e.recordAccess(this);
24             return oldValue;
25         }
26     }
27 
28     modCount++;
29     // d). 正常添加Entry，如果需要增加table长度（size>threshold）就乘2增加，并重新计算每个元素在新table中的位置和转移
30     addEntry(hash, key, value, i);
31     return null;//增加成功最后返回null
32 }
33 
34 
35 //详细说说上面的a). b). d).
36 
37 /** a). 为了防止低质量的hash函数，HashMap在这里会重新计算一遍key的hashCode **/
38 final int hash(Object k) {
39     int h = hashSeed;
40     if (0 != h && k instanceof String) {//字符串会被特殊处理，返回32bit的整数（就是int）
41         return sun.misc.Hashing.stringHash32((String) k);
42     }
43 
44     h ^= k.hashCode();//将key的hashCode与h按位异或，最后赋值给h
45 
46     // This function ensures that hashCodes that differ only by
47     // constant multiples at each bit position have a bounded
48     // number of collisions (approximately 8 at default load factor).
49     h ^= (h >>> 20) ^ (h >>> 12);
50     return h ^ (h >>> 7) ^ (h >>> 4);
51 }
52 
53 /**
54  * b). 计算此hashCode该被放入table的哪个index
55  */
56 static int indexFor(int h, int length) {
57     return h & (length-1);//与table的length - 1按位与，就能保证返回结果在0-length-1内
58 }
59 
60 /**
61  * 解决冲突：链地址法
62  * d).  addEntry(hash, key, value, i)最终是调用了此函数
63  */
64 void createEntry(int hash, K key, V value, int bucketIndex) {
65     Entry<K,V> e = table[bucketIndex];//首先table中此index的Entry拿出来
66     // 在构造函数中，e代表next。
67     // 即如果e是null，那正好设置next为null，否则将原有的Entry设置为next，新建的Entry放在此位置
68     // 也就是说这里用链地址法解决冲突时，会将原有元素放入链尾，新元素放在链头
69     table[bucketIndex] = new Entry<>(hash, key, value, e);
70     size++;
71 }