HashMap 详解

最新推荐文章于 2024-03-15 17:12:24 发布

Hinbo

最新推荐文章于 2024-03-15 17:12:24 发布

阅读量383

点赞数

分类专栏： Java 文章标签： HashMap

本文链接：https://blog.csdn.net/batter_hwb/article/details/84799242

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

总所周知，HashMap 底层是基于数组 + 链表的方式组成的，不过在 jdk1.7 和 jdk1.8 的两个版本中实现稍有不同。以下基于这两个版本做 HashMap 的底层原理解析。

一、基于JDK1.7

1、结构图
jdk1.7中数据结构

2、源码分析
JDK1.7HashMap核心成员变量
上述标记为 HashMap 中比较核心的几个成员变量，具体为：

初始化桶大小，因为底层是数组，所以这是数组默认的大小。
桶最大值。
默认的负载因子（0.75）。
table 真正存放数据的数组。
Map 存放数量的大小。
桶大小，可在初始化时显式指定。
负载因子，可在初始化时显式指定。

HashMap 底层中有两个比较重要的参数，即：容量和负载因子。容量的默认大小是 16，负载因子的默认是0.75，当 HashMap 的 size > 16*0.75 时就会发生扩容操作（容量和负载因子可以自行调整），扩容操作涉及到 rehash、复制数据等操作，所以非常消耗性能，因此通常建议能提前预估 HashMap 的大小最好，尽量的减少扩容带来的性能损耗。
默认初始化：

public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
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;
    threshold = initialCapacity;
    init();
}

根据代码可以看到其实真正存放数据的是：

transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

这个数组具体的定义为：
数组定义

Entry 是 HashMap 中的一个内部类，从他的成员变量很容易看出：

key 就是写入时的键。
value 存放的值。
next 就是用于实现链表结构。
hash 存放的是当前 key 的 hashcode。

3、put 方法

源码如下：

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

具体的分析说明：

判断当前数组是否需要初始化。
如果 key 为空，则 put 一个空值进去。
根据 key 计算出 hashcode。
根据计算出的 hashcode 定位出所在桶。
如果桶是一个链表则需要遍历判断里面的 hashcode、key 是否和传入 key 相等，如果相等则进行覆盖，并返回原来的值。
如果桶是空的，说明当前位置没有数据存入；新增一个 Entry 对象写入当前位置。

新增 Entry 对象的源码如下：

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    createEntry(hash, key, value, bucketIndex);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

当调用 addEntry 写入 Entry 时需要判断是否需要扩容，如果需要扩容则进行两倍的扩容操作，并将当前的 key 重新 hash 定位。而在 createEntry 中会将当前位置的桶传入到新建的桶中，如果当前桶有值就会在位置形成链表。

需要注意的是1.7版本中，HashMap 对于链表的插入是以头插法的方式进行的，即新数据插入在链表的头部。

4、get 方法

源码如下：

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);
    return null == entry ? null : entry.getValue();
}

final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }
    int hash = (key == null) ? 0 : hash(key);
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

具体的分析说明：

首先也是根据 key 计算出 hashcode，然后定位到具体的桶中。
判断该位置是否为链表。
不是链表就根据 key、key 的 hashcode 是否相等来返回值。
为链表则需要遍历直到 key 及 hashcode 相等时候就返回值。
啥都没取到就直接返回 null 。

二、基于JDK1.8

在 jdk1.7 版本中，当 hash 出现严重的冲突时，在每个桶上形成的链表会越来越长，这样在查询时的效率就会越来越低，时间复杂度为 O(N)。因此，在 jdk 1.8 版本中重点优化了这个查询效率。

1、结构图
jdk1.8结构图

2、源码分析

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
 * The maximum capacity, used if a higher value is implicitly specified
 * by either of the constructors with arguments.
 * MUST be a power of two <= 1<<30.
 */
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
 * The load factor used when none specified in constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;
transient Node<K,V>[] table;
/**
 * Holds cached entrySet(). Note that AbstractMap fields are used
 * for keySet() and values().
 */
transient Set<Map.Entry<K,V>> entrySet;
/**
 * The number of key-value mappings contained in this map.
 */
transient int size;

和 1.7 大体上都差不多，还是有几个重要的区别：

TREEIFY_THRESHOLD 用于判断是否需要将链表转换为红黑树的阈值。
HashEntry 修改为 Node。

Node 的核心组成其实也是和 1.7 中的 HashEntry 一样，存放的都是 key value hashcode next 等数据。

3、put 方法

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[]为数组，p是每个桶
 ①      if ((tab = table) == null || (n = tab.length) == 0) 
 	        //第一步，table为空，则调用resize()函数创建一个
            n = (tab = resize()).length;
             //第二步，计算元素所要储存的位置index,并对null做出处理
 ②      if ((p = tab[i = (n - 1) & hash]) == null)  
            //注意这里，如果tab[i]==null，说明这个位置上没有元素，这个时候就创建一个新的Node元素
            tab[i] = newNode(hash, key, value, null);
        else {  //else,否则，也就是，这个要添加的位置上面已经有元素了，也就是发生了碰撞。这个时候就要具体情况分
                //类讨论：1.key值相同，直接覆盖 2.链表已经超过了8位，变成了红黑树 3.链表是正常的链表
            Node<K,V> e; K k;
           if (p.hash == hash &&            //如果节点key存在，则覆盖原来位置的key
                ((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存在，则覆盖原来位置的key，同时将原来位置的元素，沿着链表向后移一位
                    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;
    }

具体的分析说明：

判断当前桶是否为空，空的就需要初始化（resize 中会判断是否进行初始化）。
根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空，为空表明没有 Hash 冲突就直接在当前位置创建一个新桶即可。
如果当前桶有值（ Hash 冲突），那么就要比较当前桶中的 key、key 的 hashcode 与写入的 key 是否相等，相等就赋值给 e,在第 8 步的时候会统一进行赋值及返回。
如果当前桶为红黑树，那就要按照红黑树的方式写入数据。
如果是个链表，就需要将当前的 key、value 封装成一个新节点写入到当前桶的后面（形成链表）。
接着判断当前链表的大小是否大于预设的阈值，大于时就要转换为红黑树。
如果在遍历过程中找到 key 相同时直接退出遍历。
如果 e != null 就相当于存在相同的 key,那就需要将值覆盖。
最后判断是否需要进行扩容。

注意：HashMap 在链表长度达到8的时候并不一定转红黑树，还有另外一个前提是数据的长度需要大于64，否则做的是扩容处理
jdk 1.8 版本中，HashMap 对链表的插入使用的是尾插法。

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

具体的分析说明：

首先将 key hash 之后取得所定位的桶。
如果桶为空则直接返回 null 。
否则判断桶的第一个位置(有可能是链表、红黑树)的 key 是否为查询的 key，是就直接返回 value。
如果第一个不匹配，则判断它的下一个是红黑树还是链表。
红黑树就按照树的查找方式返回值。
不然就按照链表的方式遍历匹配返回值。

jdk 1.8 对大链表做了优化，修改为红黑树之后查询效率直接提高到了 O(logn)。

参考博文：HashMap

Hinbo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
HashMap 详解

总所周知，HashMap 底层是基于数组 + 链表的方式组成的，不过在 jdk1.7 和 jdk1.8 的两个版本中实现稍有不同。以下基于这两个版本做 HashMap 的底层原理解析。一、基于JDK1.71、数据结构HashMap 底层中有两个比较重要的参数，即：容量和负载因子。容量的默认大小是 16，负载因子的默认是0.75，当 HashMap 的 size &amp;amp;gt; 16*0.75...
复制链接

扫一扫