HashMap源码分析（JDK1.8）

Posted 2020-10-05

一、HashMap简介

　　HashMap是一种基于数组+链表+红黑树的数据结构，其中红黑树部分在JDK1.8后引入，当链表长度大于8的时候转换为红黑树。

　　HashMap继承于AbstractMap（Map的骨架实现类），实现Map接口。

　　HashMap因为采用hashCode的值存储，所以性能一般情况下为O（1）。

 　   HashMap最多只允许一条记录的键为null，允许多条记录的值为null。

　　HashMap线程不安全，如在多线程环境下可以使用Collections工具类将其转换为线程安全，也可使用JDK提供的CocurrentHashMap，不建议使用HashTable，理由是并发性能一般。

二、HashMap存储结构分析

　　

　　HashMap用哈希表存储元素，其中采用链地址法解决冲突。

　　Node<K,V>是HashMap的内部实现类，实现Map.Entry<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;
        }
    }

　　

再来看看HashMap其他的几个属性：

　　

transient Node<K,V>[] table; //数组
transient int size; //实际存在键值对数
transient int modCount; //修改次数
int threshold; //所能容纳的key-value对极限
final float loadFactor; //负载因子 默认为0.75不建议修改

 

其中table默认的构造长度是16，并且要求length是2的n次方，这是一种非常规的设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。

 

当数据量增大后，即便负载因子和Hash算法设计的再合理，也避免不了链表长度增加，如此一来就会影响HashMap的性能，所以JDK1.8开始引入了红黑树，利用红黑树高性能的增删查改解决这一问题，这里不讨论红黑树。

 

三、HashMap的功能实现

1）构造HashMap　　

　　HashMap有四个构造函数：

　　　　以下就源码逐个分析构造函数

public HashMap(int initialCapacity, float loadFactor) { //构造时传入指定大小以及负载因子
        if (initialCapacity < 0)    //容量大小合法性判断
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
　　　　　//最大容量只能为MAXIMUM_CAPACTITY，2的30次方
        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); //设置阈值，当存储数据量达到阈值，将进行扩容，扩大为原来的2倍
    }

 

　　　　

 public HashMap(int initialCapacity) { //指定容量大小，负载因子使用默认值0.75，调用上面的构造器
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

 

 

public HashMap() {  //无参构造器，设置负载因子为默认值
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

 

public HashMap(Map<? extends K, ? extends V> m) { //包含子map的构造函数
        this.loadFactor = DEFAULT_LOAD_FACTOR; //设置默认负载因子
        putMapEntries(m, false); // 将传入的map元素逐个加入到HashMap中
    }

 

2）确定数组索引位置

　　

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

这是JDK1.8中确定数组索引的方法，h = key.hashCode() 为第一步 取hashCode值，h ^ (h >>> 16)  为第二步 高位参与运算，这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。

 

3）HashMap的put方法

首先是逻辑分析，put方法的处理逻辑：

①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；

②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；

③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；

④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；

⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；

⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。

看源代码实现：

　

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;
　　　　　//tab为空则新建
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //计算index，并处理null
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //通过hashcode值以及equals方法判断key是否存在，是的话直接覆盖value
            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);
　　　　　　　　　　　　　　//如果链表长度大于8转换为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
　　　　　　　　　　　　//key已经存在直接覆盖value
                    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;
    }

 

4）扩容机制

　Java中数组扩容是无法自动扩容的，方法是用新数组代替旧数组。融入了红黑树后，resize方法复杂度大大增加，这里简单说下1.7的处理的过程：

　　传入新的容量--引用扩容前的数组--判断是否达到最大容量--初始化新数组--复制数据--设置table属性引用新的数组--修改阈值

 

5）HashMap的get方法

　　HashMap存储元素是通过计算HashCode值确定精确索引存放的，但是不同的key是有可能出现有相同的HashCode值的，这时候他们会被存放在同一个桶中（bucket），

　　  然后通过equals方法来确保key的唯一性。

　　  因此当取出数据时，就要根据hash算法找到在数组的存储位置，再根据equals方法从该桶中找出对应的数据。

　　　明白了逻辑以后看源代码实现：

　　

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;
    }

 

　　

 

 

针对HashMap的学习主要理解它的存储结构，工作原理，工作原理可以通过put与get方法去理解，期间可能产生扩容；另外要明白hashcode和equals两个方法在HashMap中

的作用。此外还有一些常用的方法containsKey，clear，remove，可以查看源码学习。