Java 集合框架 HashMap

最新推荐文章于 2022-05-22 23:51:31 发布

惘昔

最新推荐文章于 2022-05-22 23:51:31 发布

阅读量103

点赞数

分类专栏： java集合篇文章标签： java

本文链接：https://blog.csdn.net/qq_43522770/article/details/120155549

版权

java集合篇专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、HashMap概述

类层次结构

主要成员属性

HashMap 作为 Map 主要的实现类，其会根据 hash 算法来计算 key-value 的存储位置并进行快速存取；
HashMap 是 Map 的一个非同步的实现，线程不安全；
最多可以存储一个 null 的 key 和多个 null 的 value，不保证顺序性；
简单地说，HashMap 是基于哈希表的 Map 接口的实现，以 Key-Value 的形式存在，即存储的对象是 Node (同时包含了 Key 和 Value) ；

HashMap的底层：数组 + 链表 (jdk7及之前) 数组 + 链表 + 红黑树（jdk8）

二、HashMap 的数据结构

在 JDK1.6 和 JDK1.7 中，HashMap 采用 数组 + 链表 实现，即使用链表处理冲突，同一 hash 值的 key-value 键值对都存储在一个链表里。但是当数组中一个位置上的元素较多，即 hash 值相等的元素较多时，通过 key 值依次查找的效率较低。
而在 JDK1.8 中，HashMap 采用 数组+链表+红黑树 实现，当链表长度超过阈值8时，并且数组总容量超过64时，将链表转换为红黑树，这样大大减少了查找时间。从链表转换为红黑树后新加入键值对的效率降低，但查询、删除的效率都变高了。而当发生扩容或 remove 键值对导致原有的红黑树内节点数量小于6时，则又将红黑树转换成链表。

三、HashMap的主要成员变量

// HashMap JDK8中的定义：
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    //默认的Hash表的长度
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
 	//Hash表的最大长度
    static final int MAXIMUM_CAPACITY = 1 << 30;
 	//默认加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
 	//当链表的长度为8的时候转化为红黑树
    static final int TREEIFY_THRESHOLD = 8;
 	//桶中元素个数小于6的时候红黑树转换为链表
    static final int UNTREEIFY_THRESHOLD = 6;
 	//只有当数组的长度大于等于64并且链表个数大于8才会转换为红黑树
    static final int MIN_TREEIFY_CAPACITY = 64;
    //Hash表
    transient Node<K,V>[] table;
    //遍历的时候使用返回一个K-V集合
    transient Set<Map.Entry<K,V>> entrySet;
	//表中K-V的个数
    transient int size;
 	//对集合的修改次数，主要是后面出现的集合校验
    transient int modCount;
 	//阈值当size大于threshold时就会进行resize
    int threshold;
 	//加载因子
    final float loadFactor;

    /**
     * Constructs an empty HashMap with the specified initial
     * capacity and the default load factor (0.75).
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * Constructs an empty HashMap with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    // 每一个HashMap都有一个Node类型的table数组，其中Node类型的定义如下：
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;         // 声明 hash 值为 final 的
        final K key;            // 声明 key 为 final 的
        V value;                // 键值对的值
        Node<K,V> next;         // 指向下一个节点的引用

        //Node为HashMap的内部类，实现了Map.Entry接口，其包含了键key、值value、下一个节点next，以及hash值四个属性。  
        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }
}

四、HashMap put() 方法

1) 判断数组是否为空，为空进行数组初始化；
2) 不为空，计算 k 的 hash 值，通过 (n - 1) & hash 计算应当存放在数组中的下标 index；
3) 查看 table[index] 是否存在数据，没有数据就构造一个 Node 节点存放在 table[index] 中；
4) 如果已经存在数据，说明发生了hash冲突(存在二个节点 key 的 hash 值一样), 继续判断 key 是否相等，若相等，用新的 value 替换原数据(onlyIfAbsent为false)；
5) 如果 key 不相等，判断当前节点类型是不是树型节点，如果是树型节点，创造树型节点插入红黑树中；(如果当前节点是树型节点，则证明当前节点已经是红黑树了)；
6) 如果不是树型节点，创建普通 Node 节点加入链表中；判断链表长度是否大于8并且数组长度大于64，若2个条件同时满足的话，则链表转换为红黑树；
7) 插入完成之后判断当前节点数是否大于阈值；如果大于，则开始扩容为原数组容量的2倍；

    //1、执行构造器 new HashMap()，创建 HashMap$Node[] table = null，并初始化加载因子 = 0.75
	public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
	//2、执行 put()方法,调用putVal()方法向当前集合中存放元素并返回对应的val
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
	//2.1 先执行 hash(key)方法，得到hash值，并返回
	static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
	//2.2 最后执行 putVal()方法
	final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //第一次put元素时，table数组为空，先调用resize生成一个指定容量的数组，如果底层table数组为null,或者 length=0 就调用resize()方法，给table数组扩容为16
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //hash值和n-1的与运算结果为桶的位置，如果该位置空，就直接放置一个Node
        //取出hash值对应的table数组索引位置的Node，如果为null,就直接创建成一个Node，加入该位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            // 通过hash值判断该索引位置处是否有值，若没有直接添加
            tab[i] = newNode(hash, key, value, null);
        else { //如果计算出的bucket不空，当前为链表不为null，即发生哈希冲突，就要进一步判断
            Node<K,V> e; K k;
            //判断当前Node的key与要put的key是否相等
            //表示当前链表第一个位置key已经存在，将当前节点赋值给e
			//如果当前table数组索引位置key的hash值（已存在的）和将要添加的key的hash值相同，并且当前table数组索引位置的key和将要添加
            //的key是同一个对象 或者 当前table数组索引位置的key和将要添加的key的 equals() 返回true，则key重复，对key-value中的value进行等价替换
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //查看当前的节点是否属于树形结构；如果是，则在TreeNode中查找并将赋值给e
            //若当前table数组索位置Node节点存储的为红黑树，则按红黑树方式处理
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //以上都不是，说明要new一个Node，加入到链表中
            else {
                //若当前table数组索位置Node节点存储的为链表，就循环比较
                for (int binCount = 0; ; ++binCount) {
                    //循环遍历整个链表，若没找到，就添加到该链表的最后
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 在已有的链表添加一个Node节点后，判断当前链表的个数，是否已达到8个，若达到后调用treeifyBin()方法判断是否进行树化(转为红黑树)
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break; //跳出死循环
                    }
                    // 在链表中继续判断是否已经存在完全相同的key，在循环比较中发现table数组Node节点的链表中已有相同的hash值 和 key，
                    // 则直接break，后续对key-value中的value进行等价替换
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // 当前节点不为null将e.val存放在oldValue
                V oldValue = e.value;
                //不管oldValue是否为null都会发生value赋值给e.value
                if (!onlyIfAbsent || oldValue == null)
                    //当出现重复的key之后上面会将节点保存给e并未修改新的val值，在此更新
                    e.value = value;
                afterNodeAccess(e);//在hashMap中，afterNodeAccess方法体为空，交给子类去实现
                return oldValue;//如果为null返回null，不为null返回对应的val
            }
        }
        ++modCount;//++modCount对其集合操作的次数+1
        if (++size > threshold) //如果在放入元素之后，数组的容量大于阈值，则调用resize()进行2倍扩容
            resize();//如果当前size超过临界值，就扩容。注意是先插入节点再扩容
        afterNodeInsertion(evict);
        return null;
    }

关于树化（转成红黑树）
   （1）如果 table 数组为 null，或者 table 数组大小还没到 64，暂时不树化，而是进行扩容，否则才会真正的树化；
   （2）当对已有红黑树进行删除操作时，若由红黑树结构 ——> 链表结构，则称之为剪枝；
   （3）在 Java 8中，如果一条链表的元素个数超过 TREEIFY_THRESHOLD（默认是8）,并且 table的大小 >= MIN_TREEIFY_CAPACITY（默认是64），就会进行树化（红黑树），否则仍然按照数组的扩容机制进行。

五、HashMap 的get操作

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的线程不安全

所有人都知道HashMap是线程不安全的，我们应该使用 ConcurrentHashMap。但是为什么 HashMap 是线程不安全的呢？

首先需要强调一点，HashMap 的线程不安全体现在会造成死循环、数据丢失、数据覆盖这些问题。其中死循环和数据丢失是在JDK1.7中出现的问题，在JDK1.8中已经得到解决，然而1.8中仍会有数据覆盖的问题，即在并发执行 HashMap 的 put 操作时会发生数据覆盖的情况。

JDK1.8的源码中已经没有transfer函数，因为JDK1.8直接在resize函数中完成了数据迁移。此外JDK1.8在进行元素插入时使用的是尾插法。为什么多线程环境下JDK1.8的HashMap会出现数据覆盖的情况呢，我们来看一下JDK1.8中的putVal源码：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //第一次put元素时，table数组为空，先调用resize生成一个指定容量的数组
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //hash值和n-1的与运算结果为桶的位置，如果该位置空就直接放置一个Node
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    //如果计算出的bucket不空，即发生哈希冲突，就要进一下判断
    else {
        Node<K,V> e; K k;
        //判断当前Node的key与要put的key是否相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //判断当前Node是否是红黑树的节点
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        //以上都不是，说明要new一个Node，加入到链表中
        else {
            for (int binCount = 0; ; ++binCount) {
             //进入这个if说明是到达链表尾部
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //在链表中继续判断是否已经存在完全相同的key
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //走到这里，说明本次put是更新一个已存在的键值对的value
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            //在hashMap中，afterNodeAccess方法体为空，交给子类去实现
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //下面两个自增操作都不是原子的
    ++modCount;
    if (++size > threshold)
        resize();
    //在hashMap中，afterNodeInsertion方法体为空，交给子类去实现
    afterNodeInsertion(evict);
    return null;
}

其中 if((p = tab[i = (n - 1) & hash]) == null) 是判断是否出现 hash 碰撞，假设两个线程A、B都在进行 put 操作，并且hash函数计算出的插入下标是相同的，当线程A执行完这行代码后由于时间片耗尽导致被挂起，而线程B得到时间片后在该下标处插入了元素，完成了正常的插入，然后线程A获得时间片，由于之前已经进行了 hash碰撞的判断，所以此时不会再进行判断，而是直接进行插入，这就导致了线程B插入的数据被线程A覆盖了，从而线程不安全。

除此之外，还有就是代码的末尾部分有个 ++size，我们这样想，还是线程A、B，这两个线程同时进行put操作时，假设当前 HashMap 的 size大小为10，当线程A执行到size自增这行代码时，从主内存中获得size的值为10后准备进行+1操作，但是由于时间片耗尽只好让出CPU，线程B拿到CPU还是从主内存中拿到size的值10进行+1操作，完成了put操作并将size=11写回主内存，由于size不是volatile修改的变量，然后线程A再次拿到CPU后不会再从主内存中加载一次size的值，而是使用自己工作内存中的副本，继续执行加1，当执行完put操作后，还是将size=11写回主内存，此时，线程A、B都执行了一次put操作，但是size的值只增加了1，所有说还是由于数据覆盖又导致了线程不安全。

惘昔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 集合框架 HashMap

一、HashMap概述类层次结构主要成员属性HashMap 作为 Map 主要的实现类，其会根据 hash 算法来计算 key-value 的存储位置并进行快速存取； HashMap 是 Map 的一个非同步的实现，线程不安全；最多可以存储一个 null 的 key 和多个 null 的 value，不保证顺序性；简单地说，HashMap 是基于哈希表的 Map 接口的实现，以 Key-Value 的形式存在，即存储的对象是 Node (...
复制链接

扫一扫