HashMap源码分析（JDK1.8）

最新推荐文章于 2022-11-30 15:57:44 发布

木叶之窗

最新推荐文章于 2022-11-30 15:57:44 发布

阅读量406

点赞数

分类专栏： JAVA底层源码分析

本文链接：https://blog.csdn.net/B_G_boy/article/details/102846232

版权

JAVA底层源码分析专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、HashMap源码分析

1.1类的继承关系

package java.util;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import sun.misc.SharedSecrets;

Hash table 是基于Map接口的实现。Hashmap的提供了所有可选的map操作并允许键和值为 null (除了不同步和允许空值，HashMap大致相当于Hashtable) Hashmap的遍历顺序是不确定的。
Hashmap的实例有两个影响其性能的参数：初始容量和加载因子，容量是哈希表中桶的数量，初始容量是哈希表创建时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。
当哈希表中的实体数量超过加载因子 * 容量时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），哈希表将扩容为大约两倍的桶数。
基本规则是默认加载因子为0.75，这样在时间和空间成本之间形成了一个良好的折中。
在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。
如果有许多映射要存储在HashMap实例中，那么在创建哈希表时使用足够大的初始容量存储效率将高于根据需要增大表的大小执行自动重新散列。
Hashmap是线程不安全的，如果多个线程同时访问一个哈希映射，并且至少有一个线程修改映射结构，必须在外部进行同步操作。（结构修改是添加或删除一个或多个映射的操作，只是改变已经存在的实例的与关键字相关的值不是结构修改。）
fast-fail事件：当多个线程对Collection进行操作时，若其中某一个线程通过iterator去遍历集合时，该集合的内容被其他线程所改变；则会抛出ConcurrentModificationException异常。因此，当存在并发修改时，迭代器会快速失败。迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

1.2 类的属性

public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
//默认初始容量是16，必须是2的幂（&操作时，jvm进行Bit位操作效率高）
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;
// 当桶(bucket)上的结点数大于等于这个值时会转成红黑树
static final int TREEIFY_THRESHOLD = 8;
// 当桶(bucket)上的结点数小于等于这个值时树转链表
static final int UNTREEIFY_THRESHOLD = 6;
// 桶中结构转化为红黑树对应的table的最小大小
static final int MIN_TREEIFY_CAPACITY = 64;
// 存储元素的数组，总是2的幂次倍
transient Node<k,v>[] table; 
// 存放具体元素的集
transient Set<map.entry<k,v>> entrySet;
// 存放元素的个数，注意这个不等于数组的长度。
transient int size;
// 每次扩容和更改map结构的计数器
transient int modCount;   
// 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
int threshold;
// 填充因子
final float loadFactor;

哈希桶结点的定义

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;//key的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;
        }
    }

1.3 类的构造函数

（1）HashMap(int, float)型构造函数

Hashmap的带参构造函数分析：
如果初始容量小于0或者加载因子小于等于0都会抛出IllegalArgumentException异常
设置的初始容量大于最大容量时，将初始容量设置为最大容量。

public HashMap(int initialCapacity, float loadFactor) {
    // 初始容量不能小于0，否则报错
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                            initialCapacity);
    // 初始容量不能大于最大值，否则为最大值
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    // 填充因子不能小于或等于0，不能为非数字
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                            loadFactor);
    // 初始化填充因子                                        
    this.loadFactor = loadFactor;
    // 初始化threshold大小
    this.threshold = tableSizeFor(initialCapacity);    
}

说明：tableSizeFor(initialCapacity)返回大于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;
}

说明：>>> 操作符表示无符号右移，高位取0。

1.4 hash算法

计算key.hashCode()，高位运算 h = key.hashCode()为32位，将这32位的高16位于低16位进行异或运算^，是高低bit都参与运算。二进制运算比模运算的效率要高。空值时默认放在桶数组的第一位

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

1.5 重要方法分析

（1）get方法

get（）根据特定的key值返回value。通过hash（key）计算key的哈希值hash，(n - 1) & hash得到所在数组的位置。（n为数组的长度）首先比较第一个结点的hash值和key是否和计算的key的hash值和key相等，如果相等，返回第一个结点；否则一次比较链表中的其他结点。

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) {
        //tab获取存在的桶数组，first找到桶数组下标所在链表的第一个结点
        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) {
            // always check first node，hash值相同key不一定相同，equals相同key、hash值一定相同
            if (first.hash == hash && 
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
            /**如果第一个结点是TreeNode的实例，说明此处不是链表，是红黑树的结构，则使用红黑树查找方法查找*/
                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;
}

（2）putVal方法

首先说明，HashMap并没有直接提供putVal接口给用户调用，而是提供的put方法，而put方法就是通过putVal来插入元素的。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
}

putVal方法执行过程可以通过下图来理解：

put（）将指定的键和值与map关联，即将此键值对放入map中。如果映射中原来有此键的映射，则将旧的值将会被替换。返回旧的值或者返回null。

/**onlyIfAbsent如果为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;
        /**如果是第一次放键值对，那么table还没有初始化，或者table的长度是0，则resize（）进行初始化*/
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**如果table的这个位置为null表示还没有此索引的结点，应该先建一个结点存放此键值对*/
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
       /**以上两种情况都不是，则依次对比链表中的结点（1）此键的结点已经存在，旧值换新值；（2）此处为树形结构，调用putTreeVal（）；（3）将此新结点放在链表末尾*/
        else {
            Node<K,V> e; K k;
        // 节点key存在，直接覆盖value 
        // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e，用e来记录
                e = p;
        // 判断该链为红黑树 
        // hash值不相等，即key不相等；为红黑树结点
            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) {       //（2）
                        p.next = newNode(hash, key, value, null);
                        //放入新节点后链表的节点数大于TREEIFY_THRESHOLD-1，则将链表树形化
                        if (binCount >= TREEIFY_THRESHOLD - 1)
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 判断链表中结点的key值与插入的元素的key值是否相等
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                    p = e;
                }
            }
            // 表示在桶中找到key值、hash值与插入元素相等的结点
            if (e != null) { //现有的键映射,当存在这个key值时返回旧的value，如果是新的值则不进行操作，即上面的else语句（2）执行了，这个if语句就不执行
                V oldValue = e.value;
                // onlyIfAbsent为false或者旧值为null
                if (!onlyIfAbsent || oldValue == null)
                    //用新值替换旧值
                    e.value = value;
                // 访问后回调
                afterNodeAccess(e);
                // 返回旧值
                return oldValue;
            }
        }
        //modCount字段主要用来记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败
        ++modCount;
        /**放入新节点后HashMap中实际存在的键值对数量大于阈值，要rehash，扩容*/
        if (++size > threshold)
            resize();
        // 插入后回调
        afterNodeInsertion(evict);
        return null;
}

（3）resize方法

①.在jdk1.8中，resize方法是在hashmap中的键值对大于阀值时或者初始化时，就调用resize方法进行扩容；

②.每次扩展的时候，都是扩展2倍；

③.扩展后Node对象的位置要么在原位置，要么移动到原偏移量两倍的位置。

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {//如果oldCap不为空的话，就是hash桶数组不为空
        ///如果大于最大容量了，就赋值为整数最大的阀值
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
         //扩充为原来的2倍newCap = oldCap << 1
         //如果当前hash桶数组的长度在扩容后仍然小于最大容量 并且oldCap大于默认值16
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold 双倍扩容阀值threshold
        }
        // initial capacity was placed in threshold
        else if (oldThr > 0) 
            newCap = oldThr;
        // zero initial threshold signifies using defaults
        else {               
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //计算新的阈值
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        //屏蔽一些无关紧要的警告
        //告诉编译器忽略 unchecked 警告信息，如使用List，ArrayList等未进行参数化产生的警告信息。
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;//将新数组的值复制给旧的hash桶数组
        //把每个bucket都移动到新的buckets中
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {//如果旧的hash桶数组在j结点处不为空，复制给e
                    oldTab[j] = null;//将旧的hash桶数组在j结点处设置为空，方便gc
                    if (e.next == null)//如果e后面没有Node结点
                        newTab[e.hash & (newCap - 1)] = e;//直接对e的hash值对新的数组长度求模获得存储位置
                    //桶的结构为红黑树，那么添加到红黑树中
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                   //桶的结构为链表
                    else { // preserve order保持顺序
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;//将Node结点的next赋值给next
/**原索引，为什么呢？如果原hash的后五位为01010，
*oldCap为10000,01010&10000 = 00000，即使newCap = oldCap<<1 = 100000,
*那么newCap-1后和hash的后五位与即11111&01010 = 00000，实际上是不变的*/
                            if ((e.hash & oldCap) == 0) {//如果结点e的hash值与原hash桶数组的长度作与运算为0
                                if (loTail == null)//如果loTail为null
                                    loHead = e;//将e结点赋值给loHead
                                else
                                    loTail.next = e;//否则将e赋值给loTail.next
                                loTail = e;//然后将e复制给loTail
                            }
                            else {//如果结点e的hash值与原hash桶数组的长度作与运算不为0
                                if (hiTail == null)//如果hiTail为null
                                    hiHead = e;//将e赋值给hiHead
                                else
                                    hiTail.next = e;//如果hiTail不为空，将e复制给hiTail.next
                                hiTail = e;//将e复制个hiTail
                            }
                        } while ((e = next) != null);//直到e为空
                        // 原索引放到bucket里
                        if (loTail != null) {//如果loTail不为空
                            loTail.next = null;//将loTail.next设置为空
                            newTab[j] = loHead;//将loHead赋值给新的hash桶数组[j]处
                        }
                        // 原索引+oldCap放到bucket里
                        if (hiTail != null) {//如果hiTail不为空
                            hiTail.next = null;//将hiTail.next赋值为空
                            newTab[j + oldCap] = hiHead;//将hiHead赋值给新的hash桶数组[j+旧hash桶数组长度]
                        }
                    }
                }
            }
        }
        return newTab;
    }

扩展：

解决hash碰撞的方式

1)链表法，在Entry对象里面增加一个next属性

public class Node{

    private Object context;
    private Node next;

    public Node(Object context, Node next){
        this.context = context;
        this.next = next;
    }

    public static void main(String[] args){
        Node header = new Node(new Object[], null);  //头节点
      
        header.next = new Node(new Object[], null); //在后面继续加节点

        header.next = new Node(new Object[], header); //放在节点的头部，指向节点的头部
    }    
}

问题：当有数据进行插入的时候，数据插入到链表的头部，然后移动链表即可（头插法，JDK1.7使用的是头插法；1.8之后是插在尾部）

put(key,value){

    int hashcode = key.hashcode();   //先算出hash值
    int index = hashcode % table.length; //JDK1.7、1.8不采用这种方式
        
    //new Entry(key,value,header);  头插法，采用下面的这种方式

    new Entry(key,value,table[index]);  //代表的就是头节点

    //table[index] = new Entry(key,value,null); 第一步插入的时候可以这样
    
    table[index] = new Entry(key,value,table[index]);  //把新的节点赋值给table数组，这样就完成了链表的头插法以及移动
    
}

问题：

1、为什么HashMap的数组里面一定要是2的幂次方数

原因：在进行hash值的&运算的时候，2的次幂进行运算时-1得到的是一个取余的结果（&操作要比%操作要快，因为进行的是Bit位的操作）

16：0001 0000

h： 0101 0101

15：0000 1111

&

0000 0101

2、为什么HashMap在算一个hashCode的值需要右移、以及进行异或运算

因为右移在进行异或运算可以防止HashMap生成的链表越来越长

3、为什么JDK1.8中HashMap选用的是红黑树而不是其他的，因为，这是一个折中的选择，既保证查询效率也保证插入效率。

参考博客：

https://www.cnblogs.com/doufuyu/p/10874689.html#3.4-hash%E7%AE%97%E6%B3%95

https://blog.csdn.net/ningchunmei1/article/details/80003107

木叶之窗

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
HashMap源码分析（JDK1.8）

1、HashMap源码分析1.1类的继承关系package java.util;import java.io.IOException;import java.io.InvalidObjectException;import java.io.Serializable;import java.lang.reflect.ParameterizedType;import java.la...
复制链接

扫一扫