Java集合详解（五）：Hashtable原理解析

1 public class Hashtable<K,V>
2     extends Dictionary<K,V>
3     implements Map<K,V>, Cloneable, java.io.Serializable

 1     // 存放hash表数据
 2     private transient Entry<?,?>[] table;
 3 
 4     // 元素数量
 5     private transient int count;
 6 
 7     // 阈值。元素数量达到该值，进行扩容
 8     private int threshold;
 9 
10     // 加载因子，默认是0.75
11     private float loadFactor;
12 
13     // 修改次数
14     private transient int modCount = 0;

 1     public Hashtable(int initialCapacity, float loadFactor) {
 2         if (initialCapacity < 0)
 3             throw new IllegalArgumentException("Illegal Capacity: "+
 4                                                initialCapacity);
 5         if (loadFactor <= 0 || Float.isNaN(loadFactor))
 6             throw new IllegalArgumentException("Illegal Load: "+loadFactor);
 7         // 如果初始化容量传入的是0，则默认使用1
 8         if (initialCapacity==0)
 9             initialCapacity = 1;
10         this.loadFactor = loadFactor;
11         table = new Entry<?,?>[initialCapacity];
12         // 计算阈值。预计的阈值为初始化容量*加载因子，预计的阈值如果大于MAX_ARRAY_SIZE + 1，则实际阈值设置为MAX_ARRAY_SIZE + 1
13         threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
14     }
15 
16     public Hashtable(int initialCapacity) {
17         // 传入初始化容量，加载因子使用默认值0.75。初始化容量传入的是多少就初始化多大（0除外；传入的如果0，默认使用1），不需要再重新计算
18         this(initialCapacity, 0.75f);
19     }
20 
21     public Hashtable() {
22         // 默认初始化容量11，默认加载因子0.75
23         this(11, 0.75f);
24     }
25 
26     public Hashtable(Map<? extends K, ? extends V> t) {
27         // 初始化容量为传入集合元素数量的2倍（至少为11），加载因子使用默认值0.75
28         this(Math.max(2*t.size(), 11), 0.75f);
29         putAll(t);
30     }

 1     protected void rehash() {
 2         int oldCapacity = table.length; // 原容量值
 3         Entry<?,?>[] oldMap = table;    // 原数组
 4 
 5         // overflow-conscious code
 6         int newCapacity = (oldCapacity << 1) + 1;   // 预计扩容的容量为原容量的2倍+1
 7         if (newCapacity - MAX_ARRAY_SIZE > 0) {
 8             if (oldCapacity == MAX_ARRAY_SIZE)  // 预计扩容容量如果大于容量最大值，并且原容量为容量最大值，则不进行扩容处理
 9                 // Keep running with MAX_ARRAY_SIZE buckets
10                 return;
11             newCapacity = MAX_ARRAY_SIZE;   // 预计扩容容量如果大于容量最大值，则将新容量设置为容量最大值
12         }
13         Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];  // 构建一个新数组
14 
15         modCount++; // 修改次数+1
16         // 计算阈值。新容量值*加载因子，与容量最大值+1，两个比较取最小值
17         threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
18         table = newMap;
19 
20         for (int i = oldCapacity ; i-- > 0 ;) {
21             // 遍历原数组，从后往前
22             for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
23                 // 遍历该索引位链表，这里与jdk8中hashmap有点区别，这里是在链表头部插入（和之前链表会反过来），hashmap是在尾部插入
24                 Entry<K,V> e = old;
25                 old = old.next;
26 
27                 int index = (e.hash & 0x7FFFFFFF) % newCapacity;
28                 e.next = (Entry<K,V>)newMap[index];
29                 newMap[index] = e;
30             }
31         }
32     }

 1     public synchronized V put(K key, V value) {
 2         // Make sure the value is not null
 3         if (value == null) {
 4             // value为空，会抛出空指针异常
 5             throw new NullPointerException();
 6         }
 7 
 8         // Makes sure the key is not already in the hashtable.
 9         Entry<?,?> tab[] = table;
10         int hash = key.hashCode();
11         int index = (hash & 0x7FFFFFFF) % tab.length;
12         @SuppressWarnings("unchecked")
13         Entry<K,V> entry = (Entry<K,V>)tab[index];
14         for(; entry != null ; entry = entry.next) {
15             if ((entry.hash == hash) && entry.key.equals(key)) {
16                 // 该key已经存在，直接替换原值
17                 V old = entry.value;
18                 entry.value = value;
19                 return old;
20             }
21         }
22         // 添加元素
23         addEntry(hash, key, value, index);
24         return null;
25     }
26     private void addEntry(int hash, K key, V value, int index) {
27         modCount++;
28 
29         Entry<?,?> tab[] = table;
30         if (count >= threshold) {   // 判断是否元素数量是否达到阈值，如果达到先进行扩容处理
31             // Rehash the table if the threshold is exceeded
32             rehash();
33 
34             tab = table;
35             hash = key.hashCode();
36             index = (hash & 0x7FFFFFFF) % tab.length;
37         }
38 
39         // Creates the new entry.
40         @SuppressWarnings("unchecked")
41         Entry<K,V> e = (Entry<K,V>) tab[index];
42         // 插入元素是在链表头部插入
43         tab[index] = new Entry<>(hash, key, value, e);
44         count++;
45     }

 1     public synchronized V remove(Object key) {
 2         Entry<?,?> tab[] = table;
 3         int hash = key.hashCode();
 4         int index = (hash & 0x7FFFFFFF) % tab.length;
 5         @SuppressWarnings("unchecked")
 6         Entry<K,V> e = (Entry<K,V>)tab[index];
 7         for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
 8             if ((e.hash == hash) && e.key.equals(key)) {
 9                 modCount++;
10                 if (prev != null) {
11                     prev.next = e.next;
12                 } else {
13                     tab[index] = e.next;
14                 }
15                 count--;
16                 V oldValue = e.value;
17                 e.value = null;
18                 return oldValue;
19             }
20         }
21         return null;
22     }
23     public synchronized boolean remove(Object key, Object value) {
24         Objects.requireNonNull(value);
25 
26         Entry<?,?> tab[] = table;
27         int hash = key.hashCode();
28         int index = (hash & 0x7FFFFFFF) % tab.length;
29         @SuppressWarnings("unchecked")
30         Entry<K,V> e = (Entry<K,V>)tab[index];
31         for (Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
32             if ((e.hash == hash) && e.key.equals(key) && e.value.equals(value)) {
33                 modCount++;
34                 if (prev != null) {
35                     prev.next = e.next;
36                 } else {
37                     tab[index] = e.next;
38                 }
39                 count--;
40                 e.value = null;
41                 return true;
42             }
43         }
44         return false;
45     }

 1     private void writeObject(java.io.ObjectOutputStream s)
 2             throws IOException {
 3         Entry<Object, Object> entryStack = null;
 4 
 5         synchronized (this) {
 6             // Write out the threshold and loadFactor
 7             s.defaultWriteObject();
 8 
 9             // Write out the length and count of elements
10             s.writeInt(table.length);
11             s.writeInt(count);
12 
13             // Stack copies of the entries in the table
14             for (int index = 0; index < table.length; index++) {
15                 Entry<?,?> entry = table[index];
16 
17                 while (entry != null) {
18                     entryStack =
19                         new Entry<>(0, entry.key, entry.value, entryStack);
20                     entry = entry.next;
21                 }
22             }
23         }
24 
25         // Write out the key/value objects from the stacked entries
26         while (entryStack != null) {
27             s.writeObject(entryStack.key);
28             s.writeObject(entryStack.value);
29             entryStack = entryStack.next;
30         }
31     }
32 
33     private void readObject(java.io.ObjectInputStream s)
34          throws IOException, ClassNotFoundException
35     {
36         // Read in the threshold and loadFactor
37         s.defaultReadObject();
38 
39         // Validate loadFactor (ignore threshold - it will be re-computed)
40         if (loadFactor <= 0 || Float.isNaN(loadFactor))
41             throw new StreamCorruptedException("Illegal Load: " + loadFactor);
42 
43         // Read the original length of the array and number of elements
44         int origlength = s.readInt();
45         int elements = s.readInt();
46 
47         // Validate # of elements
48         if (elements < 0)
49             throw new StreamCorruptedException("Illegal # of Elements: " + elements);
50 
51         // Clamp original length to be more than elements / loadFactor
52         // (this is the invariant enforced with auto-growth)
53         origlength = Math.max(origlength, (int)(elements / loadFactor) + 1);
54 
55         // Compute new length with a bit of room 5% + 3 to grow but
56         // no larger than the clamped original length.  Make the length
57         // odd if it‘s large enough, this helps distribute the entries.
58         // Guard against the length ending up zero, that‘s not valid.
59         int length = (int)((elements + elements / 20) / loadFactor) + 3;
60         if (length > elements && (length & 1) == 0)
61             length--;
62         length = Math.min(length, origlength);
63 
64         if (length < 0) { // overflow
65             length = origlength;
66         }
67 
68         // Check Map.Entry[].class since it‘s the nearest public type to
69         // what we‘re actually creating.
70         SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, length);
71         table = new Entry<?,?>[length];
72         threshold = (int)Math.min(length * loadFactor, MAX_ARRAY_SIZE + 1);
73         count = 0;
74 
75         // Read the number of elements and then all the key/value objects
76         for (; elements > 0; elements--) {
77             @SuppressWarnings("unchecked")
78                 K key = (K)s.readObject();
79             @SuppressWarnings("unchecked")
80                 V value = (V)s.readObject();
81             // sync is eliminated for performance
82             reconstitutionPut(table, key, value);
83         }
84     }