Java容器三：HashMap

HashMap

Map, Cloneable, Serializable
–>AbstractMap

---

HashMap内部是通过一个n大小的table实现的，table的每一个位置被称为一个桶，桶内可能包含很多的节点（存有key和value等值），每一个桶内的节点通过链式或树形储存。HashMap是一个fail-fast的容器。其每次扩容后的新桶数都是当前桶数的两倍（当前桶数是2的次幂）。

默认常量

// 默认HashMap容量，为2的倍数
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载，若(元素个数/桶数)>负载,则扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/** 
* 1.若每一个桶内的元素个数超过TREEIFY_THRESHOLD，
* 则将该桶内的链式存储结构调整为红黑树
* 2.若每一个桶内的元素个数小于UNTREEIFY_THRESHOLD，
* 则将该桶内的红黑树结构还原为链式结构
* 注意：若桶数小于MIN_TREEIFY_CAPACITY，
* 即使达到条件1，只会进行扩容而不会调整储存结构
*/
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;

HashMap的内部存储结构

链式结构

HashMap内部每一个子元素均以Node形式存储，如下所示，里面包含一个hash值，一个key值，一个value值和指向下一个Node的指针。

static class Node<K,V> implements Map.Entry<K,V> {
     final int hash;
     final K key;
     V value;
     Node<K,V> next;

    // 计算hash值得方法：将key的hash值和value的hash值进行异或
     public final int hashCode() {
         return Objects.hashCode(key) ^ Objects.hashCode(value);
     }
 }

红黑树结构

static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
}
// TreeNode最终继承至Node，该红黑树结构比普通红黑树结构稍复杂,
// 因为TreeNode里还存了Node的next指针以退化为Node
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
}

成员变量

// table中的每一个元素代表一个桶
transient Node<K,V>[] table;
// 并未使用额外的空间进行存储，通过调用HashMap中定义的其他方法模拟出entrySet的效果
transient Set<Map.Entry<K,V>> entrySet;
// 已储存的元素个数
transient int size;
// 和其他非线程安全容器类似，为了fail-fast
transient int modCount;
// 负载(默认值或赋新值)
final float loadFactor;
// 定义为(capacity * load factor)，size超过该值即重新分配空间
int threshold;

注意，在调用HashMap构造函数后并未立刻给table分配内存空间，而是在第一次进行插入操作时分配空间。

辅助方法

hash

HashMap重写的hash方法，采用将key值调用Object.hashCode方法得到的hash值的后16位与前16为进行异或，前16位保持不变得到新的hash值。

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

使用该方法的原因如下：
在HashMap中通过hash值计算得到内存的方法为index=hash&(n-1),n为table大小，即桶的数量，且n值为2的幂次，因此该方法会造成在计算Index时仅后$log_2n$位生效。

引自博客http://blog.csdn.net/fan2012huan/article/details/51097331

tableSizeFor

该方法的主要作用是将输入的桶的数量（cap）变成大于cap的最小2次幂的数。

static final int tableSizeFor(int cap) {
    // 当cap为2的次幂时，保证使用该方法不改变cap的值。
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

该方法的原理如下：
以cap为1**************为例，*代表该位置上的数是任意数

n |= n >>> 1;

1************** -> 11*************，将最高位的1向右传递了2位。

n |= n >>> 2;

1************** -> 1111***********，将最高位的1向右传递了4位。

n |= n >>> 4;

1111*********** -> 11111111*******，将最高位的1向右传递了8位。

n |= n >>> 8;

11111111******* -> 111111111111111，将最高位的1向右传递了16位（位数不够，仅传递了15位）。

n |= n >>> 16;

最大能将最高位的1向右传递32位，和一个int值得位数相同。

return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

最后返回(n+1)，即为2的次幂。

查找元素的实现

该方法在HashMap的内部频繁被其他方法调用。该方法的实现原理其实就是根据hash值定位到桶，再从桶中查找到期望的Node。注意，即使在桶内，每一个if的最开始都判断了一次hash值是否相同，这是因为桶的标号是通过index=hash&(n-1)计算得到，在之前解释过，这样在计算index时只会用到后n为hash值，因此有可能不同的hash值都定位到同一个桶中。

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}