HashMap源码分析

源码版本

Java8

HashMap特点

1. 采用键值对(key-value)存储;
2. HashMap中的数据结构是数组(哈希表)+单链表 + (红黑树)的组合。

概念

1. HashMap中，对象如何比较？ 在HashMap中，判断两个对象是否相等的规则是：

• 判断两个对象的hashCode是否相等
  • 如果不相等，认为两个对象也不相等，return返回
  • 如果相等，转入下一步
• 判断两个对象用equals运算是否相等 如果不相等，认为两个对象也不相等 如果相等，认为两个对象相等

这里也就是说两个对象的hashcode相等，对象不一定相等，还要使用equals方法区比较，若两个对象相等，那么它们的HashCode一定相等。

HashMap类定义

public class HashMap<K,V> extends AbstractMap<K,V>    implements Map<K,V>, Cloneable, Serializable {}

• 继承抽象类AbstractMap<K,V>，提供了map的部分实现；
• 实现Map<K,V>接口，实现Cloneable，Serializable接口，能够进行克隆拷贝，序列化。

HashMap类中属性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;     static final int MAXIMUM_CAPACITY = 1 << 30;    static final float DEFAULT_LOAD_FACTOR = 0.75f;    static final int TREEIFY_THRESHOLD = 8;    static final int UNTREEIFY_THRESHOLD = 6;    static final int MIN_TREEIFY_CAPACITY = 64;

• DEFAULT_INITIAL_CAPACITY
  默认初始容量，当实例化对象时，未设置，则默认为16
• MAXIMUM_CAPACITY
  最大容量，若构造时，传入值过大，则将被该值替换，同时，当传入值大于MAXIMUM_CAPACITY，必须为2的偶数次幂，否则，报出异常Illegal initial capacity
• DEFAULT_LOAD_FACTOR
  默认负载值，实例化对象时，构造函数未指定，默认为0.75。 该值表示含义，决定map容量扩容，当默认为HashMap(16, 0.75),默认容量为16，负载因子为0.75，当容量用到了16 * 0.75=12就进行扩容。若负载因子为1，就是16*1=16,当容量用到16才扩容。

在Java8中加入红黑树，又添加了如下属性

static final int TREEIFY_THRESHOLD = 8;static final int UNTREEIFY_THRESHOLD = 6;static final int MIN_TREEIFY_CAPACITY = 64;

-- TREEIFY_THRESHOLD
当链表长度大于该值时，转换为红黑树

Map对象中节点存在数据结构Node<K,V>

static class Node<K,V> implements Map.Entry<K,V> {        final int hash;        final K key;        V value;        Node<K,V> next;        Node(int hash, K key, V value, Node<K,V> next) {            this.hash = hash;            this.key = key;            this.value = value;            this.next = next;        }        public final K getKey()        { return key; }        public final V getValue()      { return value; }        public final String toString() { return key + "=" + value; }        public final int hashCode() {            return Objects.hashCode(key) ^ Objects.hashCode(value);        }        public final V setValue(V newValue) {            V oldValue = value;            value = newValue;            return oldValue;        }        public final boolean equals(Object o) {            if (o == this)                return true;            if (o instanceof Map.Entry) {                Map.Entry<?,?> e = (Map.Entry<?,?>)o;                if (Objects.equals(key, e.getKey()) &&                    Objects.equals(value, e.getValue()))                    return true;            }            return false;        }    }

• Node<K,V>实现的是Map.Entry<K,V>，这里就是存入Map对象中节点的存储形式，Map是由数组，链表构成，这样的Node在LinkedList中也出现过，只不过属性值不同，多了hash值。这里重写了HashCode()方法，与equals()方法，用于判断节点是否相同。
• 当两个元素的hashcode值相同时，该怎么办？
  它们会储存在同一个bucket位置的链表中。键对象的key.equals(k)方法用来找到键值对,该方法在Node<K,V>中重写了。
• 当两个对象的hashcode相同会发生什么？
  它们的bucket位置相同，‘碰撞’会发生。因为HashMap使用链表存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在链表中。HashCode相同，会存储在同一个链表中。

存储原理

• 哈希表的实现是个数组，每个值都会通过散列函数来获取对应的数组下标，从而存在数组的相应位置。一旦两个值的哈希值相同，就会用链表连接起来。如上图是通过对数组长度求模的值来获取下标。然后再遍历这个单链表，去寻找对应key值的value。

HashMap构造方法

public HashMap(int initialCapacity)    public HashMap()    public HashMap(Map<? extends K, ? extends V> m)    public HashMap(int initialCapacity, float loadFactor) {        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " +                                               loadFactor);        this.loadFactor = loadFactor;        this.threshold = tableSizeFor(initialCapacity);    }

• public HashMap(int initialCapacity, float loadFactor)
  构造函数，传入初始容量与负载因子。

• public HashMap(Map<? extends K, ? extends V> m)
  向构造方法中传入一个map,调用putMapEntries()方法，将其存入Map中，先计算容量，将传入Map的size除以负载因子，即为实际的Capacity，再调用tableSizeFor()方法,求出threshold。

HashMap核心方法

获取方法

public V get(Object key) {Node<K,V> e;return (e = getNode(hash(key), key)) == null ? null : e.value;}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;    }

• public V get(Object key);
  通过key获取，Map中对应的Value，主要是调用getNode(int hash, Object key);方法实现。
  这里传入的是通过key.hashCode()获取的Hash值。getNode()方法中，会先判断维护的table是否为空，然后再去判断first节点（为什么先要去判断first节点）；接着就是遍历，通过比较传入的hash值，确定所在的数组，再调用equals()去比较key。

添加元素

public V put(K key, V value) {        return putVal(hash(key), key, value, false, true);}final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node<K,V>[] tab; Node<K,V> 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);        else {            Node<K,V> e; K k;            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                e = p;            else if (p instanceof TreeNode)                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);            else {                for (int binCount = 0; ; ++binCount) {                    if ((e = p.next) == null) {                        p.next = newNode(hash, key, value, null);                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            treeifyBin(tab, hash);                        break;                    }                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        break;                    p = e;                }            }            if (e != null) { // existing mapping for key                V oldValue = e.value;                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }        ++modCount;        if (++size > threshold)            resize();        afterNodeInsertion(evict);        return null;    }

• 通过hash(key)计算出hash值，使用i = (n - 1) & hash计算在table中的下标，就相当于使用 (hash%tab.length),将该值存入对应的哈希表tab[i]中
• 如果该对应的单链表中为空，则直接新建一个节点，存入tab[i]中，如果对应不为空，则知道该单链表的tab[i].next为空时，存入
• 如果添加导致链表过长(>= TREEIFY_THRESHOLD)，就把链表转换成红黑树；
• 如果节点已经存在就替换old value(保证key的唯一性)
• 如果tab[]满了(超过load factor*current capacity)，就要resize。

测试

通过Debug，可以清楚看到维护的Map对象中属性值。

public static void main(String[] args) {Map<String, String> map = new HashMap<>();map.put("1", "aaa");map.put("2", "bbb");map.put("3", "ccc");map.put("4", "ddd");map.put("5", "eee");map.put("6", "fff");map.put("7", "ggg");map.put("8", "hhh");map.put("9", "jjj");map.put("10", "kkk");map.put("11", "lll");map.put("12", "mmm");map.put("13", "nnn");for(Entry<String, String> e : map.entrySet()){System.out.println(e.getKey() + "=" + e.getValue() );}}

• 其中通过i = (n - 1) & hash中计算得来，i = (16 - 1) & 49 = 1，所以存储在tab[1]中，由于该位置没有值，所以直接新建存放在该tab[1]中，若已经存在值，则需要利用p = tab[1]，p.next进行遍历，这里是维护了一个单链表。

总结

HashMap原理

• 内部通过维护数组(哈希表)+单链表(红黑树)的组合
• 用哈希桶来形容很贴切，
• 存入数据时，先通过过传入的hash(Key)，判断是哪个桶，找到指定的桶，就把数据放进去。桶里面有个单链表。
• 当桶的容量，大于负载因子*current capacity时，扩容为2倍。 获取元素时，计算出传入Key的Hash值，先定位到第一个哈希桶，然后以链表遍历桶里所有元素，逐个比较其key值
• 在JDK8里，新增默认为8的閥值，当一个桶里的Entry超过閥值，就不以单向链表而以红黑树来存放以加快Key的查找速度。

为什么要使用hashcode？

• hashCode是用来在散列存储结构中确定对象的存储地址。 HashMap就是一个大内存块，里面有很多小内存块，小内存块里面是一系列的对象，可以利用hashCode来查找小内存块hashCode%size(小内存块数量)

如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？

• 随着HashMap中元素的数量越来越多，发生碰撞的概率就越来越大，所产生的链表长度就会越来越长，这样会影响HashMap的速度，为了保证HashMap的效率，系统必须要在某个临界点进行扩容处理。该临界点在当HashMap中元素的数量等于table数组长度*加载因子。
• 每次扩大容量，为2的n次方。不同的hash值发生碰撞的概率比较小，这样就会使得数据在table数组中分布较均匀，查询速度也较快。能够采用位运算，效率要高于做除法。

HashMap和HashTable有什么区别？

• HashMap是支持null键和null值的，而HashTable在遇到null时，会抛出NullPointerException异常。HashMap中，key为null时，计算所得Hashcode为0。
• Hashtable默认的初始大小为11，之后每次扩充为原来的2n+1。HashMap默认的初始化大小为16，之后每次扩充为原来的2倍。
• Hashtable是线程安全的，HashMap不是。Hashtable中方法采用synchronized修饰。

参考

• http://yikun.github.io/2015/04/01/Java-HashMap工作原理及实现/
• http://tinylcy.me/2016/12/04/HashMap源码分析/
• http://www.cnblogs.com/xll1025/p/6420925.html
• http://www.debugease.com/j2se/297365.html
• http://www.importnew.com/19938.html

说明

• 个人总结及参考其它博客等，若有错误及不准确地方，欢迎指正。