一、HashMap中内部数据结构的真面目
HashMap的内部是由数组和链表实现的，数组中的每一个元素记录的是链表的头节点（可以为null），所以HashMap大概就长这么个样子：
在HashMap的源码中有几个比较关键的成员变量：
transient int size;
int threshold;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
final float loadFactor = DEFAULT_LOAD_FACTOR;
transient HashMapEntry<K,V>[] table = (HashMapEntry<K,V>[]) EMPTY_TABLE;
其中size表示HashMap中实际存储键值对的个数，DEFAULT_LOAD_FACTOR表示扩容因子，threshold表示阈值，当键值对个数size大于等于threshold时考虑进行扩容。threshold是怎么算出来的呢？一般而言，threshold等于table.length乘以loadFactor，比如，如果table.length为16，loadFactor为0.75，则threshold为12。table是一个HashMapEntry类型的数组，其中的每个元素指向一个单向链表，链表中的每个节点表示一个键值对，HashMapEntry是一个内部类，它的主要内部结构如下（删除了部分代码）：
// Android added.
static class HashMapEntry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
HashMapEntry<K,V> next;
int hash;
HashMapEntry(int h, K k, V v, HashMapEntry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
}
在HashMapEntry有四个成员变量，其中key和value分别用于存储键和值，而next类似于一个指针，用于记录下一个节点，最后这个hash用于记录每个节点中通过key计算出来的hash值。
通过了解HashMap上面的这些细节属性后，我们可以在来画一个HashMap更细节的结构示意图：
了解完HashMap的真面目后，又有了新的疑惑，HashMap在存储键值对的时候是如何散列存储的呢？
二、HashMap散列存储键值对的原理
谈到HashMap的存储肯定首先要看的就是它的put方法：
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);
int i = indexFor(hash, table.length);
for (HashMapEntry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
源码很简洁，但是其中的逻辑挺绕的。
如果是第一次调用put方法，会调用inflateTable（）方法来给table数组分配threshold这么大的空间。再看几个关键的点，程序会根据传入的key算一个hash值，再调用indexFor()这个方法算出一个table数组的索引值，这个方法中有一个很重要的算法，后面来分析，主要是通过这个算法让存储的数据尽量的在table数组中分布均匀。算出table数组的下标索引后再通过一个for (HashMapEntry<K,V> e = table[i]; e != null; e = e.next)循环来遍历这个链表，在循环里面会通过if (e.hash == hash && ((k = e.key) == key || key.equals(k))) 来判断当前put进来的这个节点的key是否已经存在，如果已经存在就更新keyd对应的value。
看到这里我又产生了一个疑惑，循环中只判断了当前table[i]所对应链表下的节点的key是否已经存在，存在更新value，但是key不存在就应该添加到table[i]的这个链表上的操作却没有做。在循环中没有做这个添加节点的操作，再来看看后面的 addEntry(hash, key, value, i)这个方法中的代码：
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
这个方法中首先是判断了当前的size是否达到了扩容的阈值，如果达到了扩容的阈值就先扩容，然后再算出一个bucketIndex的索引，这个索引也就是数组table的下标，最后又调用了createEntry(hash, key, value, bucketIndex)这个方法，到这里还是没有做添加节点的操作，所以得再到createEntry(hash, key, value, bucketIndex)这个方法中来看看：
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMapEntry<K,V> e = table[bucketIndex];
table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
size++;
}
这个方法中的代码简洁到我第一次没有看懂，这里有两重意思：①传进来的table索引bucketIndex所对应的链表上已经有节点，这时添加的新节点就应该链接到这个已经存在节点的链表后面；②传进来的table索引bucketIndex所对应的链表上还没有节点，这种情况就应该将添加的节点作为这个链表的头节点。但是这里并没有判断，所以巧妙的地方就在这里，通过HashMapEntry<K,V> e = table[bucketIndex];这句代码就将table[bucketIndex]对应的这个链表赋值到了e这个变量上，不管table[bucketIndex]为不为null；然后通过table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);这句代码就将新添加的节点插入到了链表的头部并链接了之前e这变量保存的链表到后面，这样就完成了新节点的插入操作。所以不管table[bucketIndex]所指向的链表是否为null，新插入的借点都在这个链表的头部。
到这里还有一个之前的疑问，就是indexFor(hash, table.length)这个方法中的算法是如何让链表分布得更均匀呢？那就得再来看看indexFor(hash, table.length)这个方法中的代码：
static int indexFor(int h, int length) {
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
return h & (length-1);
}
嗯，一行代码！！！其实这句代码就是当length为2的幂次方时，h&(length-1)等价于h%length，为什么不直接用h%length呢，因为&运算符更高效。这样说肯能并不信服，那就举个例子， 假设数组长度分别为15和16，计算出来的hash码分别为8和9，那么&运算后的结果如下：
从上面的例子中可以看出：当它们和15-1（1110）“与”的时候，产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到数组中的同一个位置上形成链表，那么查询的时候就需要遍历这个链 表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hash值会与15-1（1110）进行“与”，那么 最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！而当数组长度为16时，即为2的n次方时，2n-1得到的二进制数的每个位上的值都为1，这使得在低位上&时，得到的和原hash的低位相同，加之hash(int h)方法对key的hashCode的进一步优化，加入了高位计算，就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。
三、HashMap如果通过key获取到value
要直达这个答案很简单，看看HashMap的get(Object key)方法就知道了：
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
在get()方法中最关键的一句代码是：通过 Entry<K,V> entry = getEntry(key);这句代码获取一个到key对应的这个节点，最后从这个节点中获取到value。所以还需要再看看getEntry(key)这个方法中的代码：
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
for (HashMapEntry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
在这个方法中也是计算出key对应的hash，再通过hash计算出table数组的下标，然后循环遍历数组中这个下标对应的链表，如果hash相同，再比较key是否相同，如果都相同表示找到了这个key对应的节点，并返回这个节点。到此HashMap中根据key获取value的核心实现逻辑就了解清楚了。
四、HashMap是如何移除一个元素的
想到移除肯定就要看remove(Object key)这个方法：
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.getValue());
}
在这个方法中又调用了removeEntryForKey(key)这个方法：
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
int i = indexFor(hash, table.length);
HashMapEntry<K,V> prev = table[i];
HashMapEntry<K,V> e = prev;
while (e != null) {
HashMapEntry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
这个方法中的逻辑就稍微复杂些了，如果能明白从链表中删除一个节点元素那就很简单了。首先计算了table数组的下标，找到这个下标所对应的链表，然后用prev记录下这个链表的头节点，再循环遍历这个链表，找到要删除的节点并移除这个节点。在循环中就是通过判断hash和key是否相同来找到要删除的节点，找到过后如果要删除的节点是这个链表的头节点，就直接将table[i]指向找到这个节点的下一个节点就可以了；如果删除的是链表的非头节点，就将prev.next指向它下一个节点的next即可删除，但是每循环一次prev指针应该移动到它的下一个节点即：prev = e，这样从HashMap中移除一个节点的操作就完成了。
五、HashMap是如何扩容
在前面的有些方法中已经看到当达到扩容的条件后，HashMap就会扩容它的数组，那么HashMap是如何扩容的呢？这就要来看resize(int newCapacity)这个方法了：
void resize(int newCapacity) {
HashMapEntry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
HashMapEntry[] newTable = new HashMapEntry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
这个方法中首先会判断之前的oldCapacity是否等于MAXIMUM_CAPACITY，如果等于就将扩容的阈值threshold设置为Integer.MAX_VALUE，然后会new出一个容量为newCapacity这个么大的新数组，再调用transfer(newTable)方法将以前的数组中的元素拷贝到新数组中，最后将新数组赋值给table。所以核心的操作就应该来到transfer(HashMapEntry[] newTable)这个方法了：
void transfer(HashMapEntry[] newTable) {
int newCapacity = newTable.length;
for (HashMapEntry<K,V> e : table) {
while(null != e) {
HashMapEntry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
这个方法中主要是遍历table数组中的元素所对应的链表，调用indexFor(e.hash, newCapacity)方法重新计算出一个新的i再将之前的链表搬家到newTable[i]这个位置。扩容后HashMap在添加元素的时候就能减少链表的长度，提高了HashMap增删改查的效率。这么说肯能很难理解清楚，现在来画几个图理解哈。
在执行该方法之前假设table和newTable是这个样子： 
这里假设table数组中有两个散列链表，每个字母表示每个节点中存储的value，newTable这个数组还没有链表。现在假设第一次while循环进来的e这个节点就是存储A字母的这节点，所以执行完 HashMapEntry<K,V> next = e.next;这句代码后，next就指向了存储B字母的这个节点了（即指向了存储A后面的这个串）。当执行完 int i = indexFor(e.hash, newCapacity);这句代码后，假设i = 1，e.next = newTable[i];执行后这幅图就变成下面这个样子了：
接着往后面走，执行newTable[i] = e;这句代码过后的图：
再往后面走，执行e = next;这句代码后：
这样经过一次while循环过后就将table中存储A字母的节点搬运到newTable中去了，最终将table中的这个链表遍历后的图如下：
其实在table中的每个链表的尾节点上都应该有一个NULL节点，这里就没有画出来了，看完这个执行过程示意图应该能明白transfer(HashMapEntry[] newTable)这个方法了。
六、自定义HashMap
看完了HashMap中的几个核心方法后我也来自定义一个MyHashMap，这里简单的实现其中的增删改查方法。实现的代码如下：
public class MyHashMap<K, V> {
private int size;//当前存放元素的大小
private int threshold;//扩容的阈值
private final float DEFAULT_LOAD_FACTOR = 0.75f;//默认扩容因子
private MyHashMapEntry<K, V>[] table;//存放链表的数组
private final int DEFAULT_INITIAL_CAPACITY = 16;//数组的默认容量
private static class MyHashMapEntry<K, V> {
private K key;
private V value;
private int hash;
private MyHashMapEntry<K, V> next;
MyHashMapEntry(int hash, K key, V value, MyHashMapEntry<K, V> next) {
this.key = key;
this.value = value;
this.hash = hash;
this.next = next;
}
}
public MyHashMap() {
threshold = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = (MyHashMapEntry<K, V>[]) new MyHashMapEntry[DEFAULT_INITIAL_CAPACITY];
}
//ToDo 1、根据key计算出hash；
//ToDo 2、根据hash算出table中对应的数组下标
//ToDo 3、遍历数组下标对应的链表
//ToDo 4、判断是否需要扩容再添加元素
public V put(K key, V value) {
int hash = hashKey(key);
int tableIndex = indexFor(hash, table.length);
//如果key已经存在，就更新它的value
for (MyHashMapEntry<K, V> e = table[tableIndex]; e != null; e = e.next) {
if (e.hash == hash && (e.key == key || key.equals(e.key))) {
//添加的元素的key已经存在，更新它的Value
V oldValue = e.value;
e.value = value;
return oldValue;
}
}
//判断是否需要扩容
if (size >= threshold && null != table[tableIndex]) {
resize(2 * table.length);
hash = (null == key) ? 0 : hashKey(key);
tableIndex = indexFor(hash, table.length);
}
//添加元素
MyHashMapEntry<K, V> e = table[tableIndex];
table[tableIndex] = new MyHashMapEntry<>(hash, key, value, e);
size++;
return null;
}
private int hashKey(K key) {
int h = 0;
h ^= key.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
private int indexFor(int hash, int length) {
return hash & (length - 1);
}
private void resize(int newCapacity) {
MyHashMapEntry<K, V>[] newTable = new MyHashMapEntry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int) (DEFAULT_LOAD_FACTOR * newTable.length);
}
private void transfer(MyHashMapEntry<K, V>[] newTable) {
int newCapacity = newTable.length;
for (MyHashMapEntry<K, V> e : table) {
while (null != e) {
MyHashMapEntry<K, V> next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
//根据key获取value
public V get(K key) {
if (key == null) return null;
MyHashMapEntry<K, V> entry = getMyHashMapEntry(key);
return null == entry ? null : entry.value;
}
private MyHashMapEntry<K, V> getMyHashMapEntry(K key) {
if (size == 0) return null;
int hash = hashKey(key);
int tableIndex = indexFor(hash, table.length);
for (MyHashMapEntry<K, V> e = table[tableIndex]; e != null; e = e.next) {
if (e.hash == hash && (e.key == key || key.equals(e.key))) {
return e;
}
}
return null;
}
//根据key移除元素
public V remove(K key) {
MyHashMapEntry<K, V> entry = removeEntryForKey(key);
return entry == null ? null : entry.value;
}
private MyHashMapEntry<K, V> removeEntryForKey(K key) {
if (size == 0) return null;
int hash = hashKey(key);
int tableIndex = indexFor(hash, table.length);
MyHashMapEntry<K, V> prev = table[tableIndex];
MyHashMapEntry<K, V> entry = prev;
while (entry != null) {
MyHashMapEntry<K, V> next = entry.next;
if (entry.hash == hash && (entry.key == key || key.equals(entry.key))) {
if (prev == entry) {
table[tableIndex] = next;
} else {
prev.next = next;
}
size--;
return entry;
}
prev = entry;
entry = next;
}
return entry;
}
}
再来一段测试代码：
public class TestMyHashMap extends AppCompatActivity {
private MyHashMap<String, Integer> mMyHashMap;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test_my_hash_map);
mMyHashMap = new MyHashMap<>();
}
public void addElement(View view) {
mMyHashMap.put("hello", 10);
mMyHashMap.put("test", 15);
mMyHashMap.put("key", 59);
mMyHashMap.put("value", 39);
mMyHashMap.put("position", 48);
mMyHashMap.put("hello", 29);
}
public void getValue(View view) {
Log.e("tt", "value = " + mMyHashMap.get("hello"));
Log.e("tt", "value = " + mMyHashMap.get("test"));
Log.e("tt", "value = " + mMyHashMap.get("key"));
Log.e("tt", "value = " + mMyHashMap.get("value"));
Log.e("tt", "value = " + mMyHashMap.get("position"));
}
}
再来看看内存中的结构是不是这样呢： 
存放了六个元素，但是可以看到内存中的size=5，因为有一个key是重复的所以后面的覆盖了前面的值。而table数组中只有4个有值，是因为数组下标为0的链表中存储了两个元素，next中存储了一个元素，所以这样一分析和验证可以证明存储的结构是正确的，数组中链表也是散列开了的。
现在来总结下HashMap的一些特点：
- HashMap存储的元素是无序的；
- HashMap是支持
key和value为null的； - HashMap是通过数组加链表来实现的，其增删改查的效率比较高；
1324
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
