hashmap是散列表吗_HashMap实现原理简析(哈希表)

什么是HashMap

HashMap在应用层的使用非常广泛，用来储存键值对。它使用哈希函数来做索引因此性能较高。同TreeMap相比，HashMap的插入、删除、查询时间复杂度在理想情况下达到O(1)。JDK1.8后，HashMap采用了TreeMap优化链表，因此极端情况下插入、删除、查询的效率也比线性好，达到O(lgN)。而JDK1.8以前，HashMap使用链表处理哈希碰撞，所以极端情况时间复杂度为O(N)。

什么情况用HashMap

当开发者想要储存有关联的键值对时，在不考虑并发安全性和有序性的前提下，应该使用HashMap。

例如:

public static class Node implements Comparable{

public Node(int v){

this.value = v;

}

public int value;

@Override

public int compareTo(Node o) {

return this.value-o.value;

}

}

public static void main(String[] args) {

Map map=new HashMap<>();

map.put(new Node(6), new Object());

map.put(new Node(3), new Object());

map.put(new Node(5), new Object());

map.put(new Node(4), new Object());

map.put(new Node(1), new Object());

map.put(new Node(11), new Object());

Iterator iterator = map.keySet().iterator();

while(iterator.hasNext()){

Node n = iterator.next();

System.out.println(n.value+" , "+map.get(n));

}

}

输出结果:

5 , java.lang.Object@33909752

11 , java.lang.Object@55f96302

1 , java.lang.Object@3d4eac69

6 , java.lang.Object@42a57993

3 , java.lang.Object@75b84c92

4 , java.lang.Object@6bc7c054

HashMap运行插入的键是null，如果键是null，其哈希值为0，所以null型键值对会插入到数组的首个位置。

HashMap内部实现

基于JDK1.8分析

HashMap结构图.png

HashMap内部依赖数组、链表、红黑树实现。

数组/链表节点

static class Node implements Map.Entry {

final int hash;

final K key;

V value;

Node next;

}

HashMap将插入的键值对封装在Node对象中，每个Node对象含有hash值，键对象key，值对象value。当哈希值冲突后，新增的Node会被next变量指向，组成链表。当该链表的长度超过8，将其转换为红黑树节点。

红黑树节点

static final class TreeNode extends LinkedHashMap.Entry {

TreeNode parent; // red-black tree links

TreeNode left;

TreeNode right;

TreeNode prev; // needed to unlink next upon deletion

boolean red;

}

容量及扩容

HashMap构造方法并没有对内部的table数组初始化，可能是为了防止未使用的情况下浪费内存。当初次执行插入，如果数组为空就会初次调用扩容方法resize()创建table数组。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

boolean evict) {

Node[] tab; Node p; int n, i;

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length; //初次调用扩容函数

...

if (++size > threshold)

resize();

}

final Node[] resize() {

Node[] oldTab = table;

int oldCap = (oldTab == null) ? 0 : oldTab.length; //初始长度为0

int oldThr = threshold; //如果HashMap构造方指定了初始长度和加载因子，threshold会被计算出来

int newCap, newThr = 0;

if (oldCap > 0) {

//第二次及以后的扩容走这里

if (oldCap >= MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

return oldTab;

}

else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

oldCap >= DEFAULT_INITIAL_CAPACITY)

newThr = oldThr << 1; // double threshold

}

else if (oldThr > 0) // initial capacity was placed in threshold

newCap = oldThr; //初始化长度和加载因子走这里

else { // zero initial threshold signifies using defaults //初始默认执行这个分支

newCap = DEFAULT_INITIAL_CAPACITY; //默认长度

newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //默认临界值

}

}

如果未指定HashMap的构造方法参数，数组初始长度为DEFAULT_INITIAL_CAPACITY(16)，加载因子为DEFAULT_LOAD_FACTOR(0.75)。开发者也可以通过HashMap的构造方法指定初始长度和加载因子。

HashMap的容量超过当前数组长度*加载因子，就会执行resize()算法，该算法将创建一个新的数组，长度是原来的两倍(旧的长度左移一位)，并且将原来的HashMap数组的节点转换到新的数组。同时threshold变量也会是原来的两倍，该变量用来判断HashMap在插入后是否应该扩容。

** 疑问：为什么扩容要将原长度左移一位呢? 因为性能问题？**

插入算法

取哈希值

public V put(K key, V value) {

return putVal(hash(key), key, value, false, true);

}

static final int hash(Object key) {

int h;

return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

}

首先调用Object的hashCode()方法算出key的哈希值，该方法在native层实现。接着将key的哈希值(int型32位)无符号右移16位，即取它的高16位返回,右移后高16位变成0，原高16位移动到低16位。

取数组中的位置

再来看具体的插入putVal方法:

Node[] tab; Node p; int n, i;

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

if ((p = tab[i = (n - 1) & hash]) == null)

tab[i] = newNode(hash, key, value, null);

这里n是table数组的长度，hash是key的哈希值经过高16位转低16位的int值。

这里计算节点在table数组的位置的算法是:i = (n - 1) & hash，将数组长度减1后与运算hash。这个算法就很巧妙了，记得上面说过数组的长度一定是2的幂，即使初始长度非2的幂也会强制转换为2的幂:

this.threshold = tableSizeFor(initialCapacity);

static final int tableSizeFor(int 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=5，最后输出长度为8。加入传入cap=9，最后输出长度为16。所以n-1的二进制形式分别是111,1111。

** 用hash与(n-1)做位置运算相比%运算更高效，这可能就是HashMap数组长度为2的幂的原因吧。并且这种巧妙的设计也能保证位置i不会超过数组长度。**

非冲突的情况

if ((p = tab[i = (n - 1) & hash]) == null)

tab[i] = newNode(hash, key, value, null);

Node newNode(int hash, K key, V value, Node next) {

return new Node<>(hash, key, value, next);

}

根据key算出hash值后，再通过** “(n-1)&hash” **算出键值对在数组中对应的位置，如果table[i]为空直接将键值对封装到Node插入table[i]。

冲突的情况

首个位置的键与新插入的键相等

if (p.hash == hash &&

((k = p.key) == key || (key != null && key.equals(k))))

e = p;

当table[i]非空，且key==table[i].key 或者 key非空，key.equals(table[i],key)。说明table[i]上的节点的键key等同于新插入的键，这种情况下令新插入的节点为table[i]。下面会将table[i]中的value替换为新插入的value。

首个位置是红黑树的节点

else if (p instanceof TreeNode)

e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);

上面说到，如果哈希表发生了哈希碰撞，冲突的节点会插入到以table[i]为链表头的尾部。如果该链表长度超过8，会转换成红黑树。因此table[i]既可能是链表头，也可能是红黑树的根部。

如果tablei是红黑树的节点，说明该hash值冲突的节点冲过了8个，将新的键值对插入红黑树。

首个位置是链表节点

for (int binCount = 0; ; ++binCount) {

if ((e = p.next) == null) { @1

p.next = newNode(hash, key, value, null);

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

treeifyBin(tab, hash); @3

break;

}

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

@2

break;

p = e;

}

@1 如果遍历到链表的末尾，说明遍历的过程中未找到key相等的节点，将键值对插入末尾

@2 如果遍历链表的过程中，存在哈希值一致，引用相等或equals相等的节点，终止遍历，新键值对的值会替换这个节点上原来的值。

@3 在链表末尾插入新节点后，链表的长度达到8，此时方法treeifyBin(tab, hash)将链表转换为红黑树

替换原节点中的Value

if (e != null) { // existing mapping for key

V oldValue = e.value;

if (!onlyIfAbsent || oldValue == null)

e.value = value;

afterNodeAccess(e);

return oldValue;

}

对于已经在链表或红黑树存在的节点，只会替换原Value就返回。

插入后的扩容

++modCount;

if (++size > threshold)

resize();

afterNodeInsertion(evict);

return null;

在前面已经描述过，当HashMap的size超过了 长度*负载因子，就会执行resize()方法扩容，将原table数组长度扩大两倍。

if (oldTab != null) {

for (int j = 0; j < oldCap; ++j) {

Node e;

if ((e = oldTab[j]) != null) {

oldTab[j] = null;

if (e.next == null)

newTab[e.hash & (newCap - 1)] = e; @1

else if (e instanceof TreeNode) @2

((TreeNode)e).split(this, newTab, j, oldCap);

else { // preserve order @3

Node loHead = null, loTail = null;

Node hiHead = null, hiTail = null;

Node next;

do {

next = e.next;

if ((e.hash & oldCap) == 0) {

if (loTail == null)

loHead = e;

else

loTail.next = e;

loTail = e;

}

else {

if (hiTail == null)

hiHead = e;

else

hiTail.next = e;

hiTail = e;

}

} while ((e = next) != null);

if (loTail != null) {

loTail.next = null;

newTab[j] = loHead;

}

if (hiTail != null) {

hiTail.next = null;

newTab[j + oldCap] = hiHead;

}

}

}

}

}

这段代码将原数组中的元素插入到新数组中，具体表现为:

@1 将非链表非红黑树的节点计算新位置后重新插入新数组。

@2 将原红黑树插入新的数组

@3 将原链表插入新的数组

这里要注意的是，扩容后(n-1)的值在高一位多了1，因此原来的链表和红黑树的节点的位置可能出现高一位多了1，所以不能简单的直接将头节点移动到新数组,需要重新计算位置。而哈希值不需要重新计算，所以这可能就是** (n-1)&hash **这个算法的好处吧。

取出算法

public V get(Object key) {

Node e;

return (e = getNode(hash(key), key)) == null ? null : e.value;

}

final Node getNode(int hash, Object key) {

Node[] tab; Node 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)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;

}

取出算法其实就是插入算法的逆向过程，你可能直接从table[i]中取走键值对，也可能是红黑树或者链表中的一个节点。

要注意的是只满足equlas相等并不能有效取出元素，还必须满足哈希值相等，所以要考虑重写key的hashCode()方法。

HashMap小结

JDK1.8以后用红黑树对HashMap的链表做了优化，因此使得HashMap的最差性能从O(n)提升到O(lgn)。

扩容是一件很耗费性能和内存的事情，除了要创建新数组，还要将原数组中的链表或红黑树重新计算位置(不重新计算哈希值)，然后插入新的数组。

如果HashMap创建时就知道对面的是多大容量的数据，可以指定初始容量和负载因子。

HashMap和TreeMap都是非线程安全的，建议使用ConcurrentHashMap处理并发安全问题。Hashtable的并非像ConcurrentHashMap对数组的每个位置加锁，而是对操作加锁，性能较差。另外Collections.synchronizedMap(map)这种方法也是在Map对象的方法上装饰了synchronized关键字，因此同Hashtable性能较差。

LinkedHashMap继承于HashMap，替HashMap完成了输入顺序的记录功能，所以要想实现像输出同输入顺序一致，应该使用LinkedHashMap。

参考