Java 集合框架:HashMap

Posted 当年明月

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 集合框架:HashMap相关的知识,希望对你有一定的参考价值。

HashMap

HashMap 的重要性和面试问到的频率不言而喻,这篇文章我们就 HashMap 的原理和代码来进行分析。

什么是哈希表

讨论哈希表之前,我们先来把一些常用的数据结构的增删改查的性能比较一下。

数组:采用一段连续的存储单元来存储数据。对与指定下标的查找和插入,其时间复杂度为 O(1),通过给定值查找,需要遍历数组,逐一比对,时间复杂度为 O(n)。对于删除操作,涉及到数组元素的移动,时间复杂度也为 O(n)。

线性链表:对于新增和删除操作,只需要更改引用即可,时间复杂度为 O(1)。查找操作需要遍历链表,时间复杂度为 O(n)。

二叉树:对于一颗相对平衡的有序二叉树,对其进行插入,查找,删除等操作,平均复杂度为 O(logn)。

哈希表:在不考虑哈希冲突的情况下,对哈希表中的数据进行添加,删除和查找等操作仅需要一次定位就可以完成,时间复杂度为 O(1)。哈希表是如何实现的那?

其实数据结构在物理存储层面只有两种:顺序存储结构和链式存储结构(像栈,队列,树,图等结构都是从逻辑结构中抽象的,映射到内存中,也是这两种形式)。哈希表的底层就是利用了数组,所以才能达到 O(1) 的时间复杂度。

哈希冲突:我们使用哈希表的时候,如果计算出来的地址相同怎么办?这就是哈希冲突。所以哈希函数的设计至关重要,好的哈希函数能够保证 计算简单和散列均匀分布。有了冲突怎么解决那?HashMap 底层数据结构是数组,每个数组节点里面放着链表,链表中的每个节点就是哈希表中的元素,在 JDK 1.8 中,当链表长度达到 8 时,链表会转化为红黑树,以便提高插入和查询效率。

概要

HashMap 是一个关联数组,哈希表。线程不安全,允许 key 为 null,value 为 null。底层数据结构是数组,每个数组节点里面放着链表,链表中的每个节点就是哈希表中的元素,在 JDK 1.8 中,当链表长度达到 8 时,链表会转化为红黑树,以便提高插入和查询效率。

代码分析

HashMap 的底层是数组,那么数组里面保存的是什么那?答案就是 Entry 键值对,key-value 键值对。1.8 改成了 Node 节点,原理相同。

//HashMap的主干数组,可以看到就是一个Entry数组,初始值为空数组{},主干数组的长度一定是2的次幂,至于为什么这么做,后面会有详细分析。
transient Node<k,v>[] table;//存储(位桶)的数组</k,v> 

Entry 类

//Node是单向链表,它实现了Map.Entry接口  
static class Node<k,v> implements Map.Entry<k,v> {  
    final int hash;  
    final K key;  
    V value;  
    Node<k,v> 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;  
    }  

    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;  
    }  
    //判断两个node是否相等,若key和value都相等,返回true。可以与自身比较为true  
    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 的存储结构如下:

img

如果我们对 HashMap 进行操作时不包含链表,那么时间复杂度就是 O(1),如果包含链表,时间复杂度就是 O

(n)。JDK 1.8 为了提高性能,在链表长度为 8 时,会将链表转换为红黑树,这时时间复杂度就是 O(logn)。

其他几个重要字段:

//实际存储的key-value键值对的个数
transient int size;
//阈值,当table == {}时,该值为初始容量(初始容量默认为16);当table被填充了,也就是为table分配内存空间后,threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold,后面会详细谈到
int threshold;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//负载因子,代表了table的填充度有多少,默认是0.75
final float loadFactor;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//用于快速失败,由于HashMap非线程安全,在对HashMap进行迭代时,如果期间其他线程的参与导致HashMap的结构发生变化了(比如put,remove等操作),需要抛出异常ConcurrentModificationException
transient int modCount;

get 方法

public V get(Object key) {  
    Node<K,V> e;  
    return (e = getNode(hash(key), key)) == null ? null : e.value;  
}  
/** 
     * Implements Map.get and related methods 
     * 
     * @param hash hash for key 
     * @param key the key 
     * @return the node, or null if none 
     */  
final Node<K,V> getNode(int hash, Object key) {  
    Node<K,V>[] tab;//Entry对象数组  
    Node<K,V> first,e; //在tab数组中经过散列的第一个位置  
    int n;  
    K k;  
    /*找到插入的第一个Node,方法是hash值和n-1相与,tab[(n - 1) & hash]*/  
    //也就是说在一条链上的hash值相同的  
    if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {  
        /*检查第一个Node是不是要找的Node*/  
        if (first.hash == hash && // always check first node  
            ((k = first.key) == key || (key != null && key.equals(k))))//判断条件是hash值要相同,key值要相同  
            return first;  
        /*检查first后面的node*/  
        if ((e = first.next) != null) {  
            if (first instanceof TreeNode)  
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);  
            /*遍历后面的链表,找到key值和hash值都相同的Node*/  
            do {  
                if (e.hash == hash &&  
                    ((k = e.key) == key || (key != null && key.equals(k))))  
                    return e;  
            } while ((e = e.next) != null);  
        }  
    }  
    return null;  
}

根据 key 计算出 hash 值,然后 hash&(n-1)得到在数组中存储的位置,通过遍历链表或者红黑树得到想要的元素,hash 相同,key 相同才满足。

put 方法

public V put(K key, V value) {  
    return putVal(hash(key), key, value, false, true);  
}  
/** 
     * Implements Map.put and related methods 
     * 
     * @param hash hash for key 
     * @param key the key 
     * @param value the value to put 
     * @param onlyIfAbsent if true, don\'t change existing value 
     * @param evict if false, the table is in creation mode. 
     * @return previous value, or null if none 
     */  
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;  
    /*如果table的在(n-1)&hash的值是空,就新建一个节点插入在该位置*/  
    if ((p = tab[i = (n - 1) & hash]) == null)  
        tab[i] = newNode(hash, key, value, null);  
    /*表示有冲突,开始处理冲突*/  
    else {  
        Node<K,V> e;   
        K k;  
        /*检查第一个Node,p是不是要找的值*/  
        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个,看是否需要改变冲突节点的存储结构,               
                    //treeifyBin首先判断当前hashMap的长度,如果不足64,只进行  
                    //resize,扩容table,如果达到64,那么将冲突的存储结构为红黑树  
                    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;  
            }  
        }  
        /*就是链表上有相同的key值*/  
        if (e != null) { // existing mapping for key,就是key的Value存在  
            V oldValue = e.value;  
            if (!onlyIfAbsent || oldValue == null)  
                e.value = value;  
            afterNodeAccess(e);  
            return oldValue;//返回存在的Value值  
        }  
    }  
    ++modCount;  
    /*如果当前大小大于门限,门限原本是初始容量*0.75*/  
    if (++size > threshold)  
        resize();//扩容两倍  
    afterNodeInsertion(evict);  
    return null;  
}
  1. 判断键值对数组是否为空或者 null,否则以默认大小 resize()。
  2. 根据 key 计算的哈希值得到在数组中的所以,如果此时 [i] 为空,直接插入链表头部
  3. 不为空判断当前时链表还是红黑树,执行插入,如果 key 相同,则替换。

哈希值的计算其实是经过两遍哈希函数的,先用 key 计算 hashCode,然后用 hashCode 再次进行哈希,保证散列均匀。这个过程有很多位运算,效率比较高。

img

resize() 扩容方法

当容量达到阈值的时候,就会对数组进行扩容,数组长度发生变化,存储位置 index = h&(length-1) 也会发生变化,需要重新计算 index。

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    //for循环中的代码,逐个遍历链表,重新计算索引位置,将老数组数据复制到新数组中去(数组不存储实际数据,所以仅仅是拷贝引用而已)
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            //将当前entry的next链指向新的索引位置,newTable[i]有可能为空,有可能也是个entry链,如果是entry链,直接在链表头部插入。
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

我们的数组索引位置的计算是通过 对key值的hashcode进行hash扰乱运算后,再通过和 length-1进行位运算得到最终数组索引位置。每次扩容会扩大为原来的两倍。HashMap 的数组长度一定是 2 的次幂是因为这个值可以是 Hash 算法散列的更加均匀。

另外我们重写 equals 方法之后也要重写 hashCode 方法,因为如果 equals 判断两个对象相等了,但是因为没有重写 hashCode 方法在进行 HashMap的相关操作时很有可能拿到错误的值。

另外 HashMap 允许插入 null key 和 value,null key 会被放入到 Table[0]。

String 和 Integer 这样的包装类适合作为 key 是因为:

  1. 他们时 final 类型,保证了 key 的不可变性,不会出现 hash 值不同的情况。
  2. 内部重写了 equals 和 hashCode 方法,严格的遵守规范,不会出现 hash 值计算错误。

高并发时 HashMap 会出现的问题

HashMap 的容量时有限的,当经过多次插入时,使得 HashMap 的大小达到了阈值,冲突记录就会很高,这时就需要进行扩容给,resize。

影响发生Resize的因素有两个:

1.Capacity

HashMap的当前长度。上一期曾经说过,HashMap的长度是2的幂。

2.LoadFactor

HashMap负载因子,默认值为0.75f。

衡量HashMap是否进行Resize的条件如下:

HashMap.Size >= Capacity * LoadFactor

扩容的具体步骤:

1.扩容

创建一个新的Entry空数组,长度是原数组的2倍。

2.ReHash

遍历原Entry数组,把所有的Entry重新Hash到新数组。为什么要重新Hash呢?因为长度扩大以后,Hash的规则也随之改变。

让我们回顾一下Hash公式:

index = HashCode(Key) & (Length - 1)

多线程环境下 ReHash 会带来什么问题?

Hashmap的Resize包含扩容和ReHash两个步骤,ReHash在并发的情况下可能会形成链表环,从而造成程序死循环。

在 JDK 1.8 里面修复了这个问题,转移数据时按照链表的正序遍历,在新链表的尾部插入,不会出现逆序,倒置的情况,故不容易成环。

JDK 1.8 HashMap 的改动

hash 算法的优化

增加了红黑树

修复了 rehash 在多线程环境下死循环的问题。

以上是关于Java 集合框架:HashMap的主要内容,如果未能解决你的问题,请参考以下文章

Java7/8集合框架——HashMap

Java 集合框架—— HashMap

Java集合框架中的Hashtable、HashMap、HashSet、哈希表概念

java集合框架 hashMap 简单使用以及深度分析(转)

Java中最常用的集合类框架之 HashMap

java源码分析之集合框架HashMap 10