Java集合-----HashMap详解

最新推荐文章于 2025-05-25 18:08:39 发布

原创最新推荐文章于 2025-05-25 18:08:39 发布 · 550 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#hashmap

Java集合专栏收录该内容

8 篇文章

订阅专栏

本文详细介绍了HashMap的内部工作机制，包括如何存储key-value键值对、使用哈希算法进行高效查找、如何避免hash冲突，以及HashMap的resize()扩容机制。重点讨论了HashMap的hash算法和put方法，以及何时进行扩容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概述

HashMap是Map接口的一个是实现类，用来存储一组key-value键值对

如何表示key-value键值对

class Node<K,V>{
    K key;
    V value;
}

我们自定义了一个Node类，只有两个属性，一个是key属性，表示键，一个value属性表示值。

如何存储key-value键值对

存储key-value键值对的方式有两种：

①使用链表：大小不限，插入和删除性能好，查找效率低

②使用数组：大小有限，插入和删除性能差，查找效率高。

一般来说，我们使用HashMap来存储数据，对于键值对的查找操作居多，所以我们一般使用数组来存储键值对

如何有效地根据key值查找value？

一种方式是通过遍历数组中的每一个元素，每遍历一个元素判断其key值是否是我们想要查找的，但是这种方式效率很低。我们使用数组存储key-value键值对的初衷就是希望查找效率高。

另一种方式，我们需要建立一种key和index之间的映射关系，这样，我们每次查找一个key时，首先根据映射关系，计算出对应数组的下标，然后根据下标直接找到对应的key-value对象。

这里将key映射成index的方法称为 hash算法。

如何避免hash冲突？

我们使用hash算法计算出来的数组下标难免会有重复的，我们需要使用什么办法来避免hash冲突呢？

① 链地址法：将哈希值相同的元素构成一个单链表，并将单链表的头结点放在哈希表中的第i个单元中

② 再哈希法

③ 开放地址法

哈希算法

我们上面提到过为了方便我们快速的查找元素在数组中的位置，我们需要使用hash算法麻将key映射成index。

由于数组的长度是有限的，我们先将key映射成整数，再将这个整数映射成下标。
对于 key->int这部分，使用的hash function(散列函数)，对于int->index这部分来说，我们使用数组的大小取模实现。

hash function

hash function即散列函数，又称散列算法，哈希函数，是一种从任何一种数据中创建小的数字的方法。

在java中，hash函数是一个native方法，它定义在Object类中，所有类都会继承。

HashMap中定义了自己定散列方法:

HashMap中的hash算法

HashMap（JDK1.8）定义了自己的Hash算法：

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

我们都知道int类型是32位的，**h=key.hashCode()^h>>>16其实是将key的hashCode的高16位与低16位进行异或操作。**使得该hashCode映射成数组下标时更均匀。
在这里插入图片描述这样干有什么用呢？我们先来看一看HashMap中关于数组下标的计算：

n = table.length;
index = （n-1） & hash;

  这里的n指的是2的幂次方数。table的长度都是2的幂，因此计算index仅与hash值的低n位有关。
  例：table.length = 2^4 = 16，其32位表示为：0000 0000 0000 0000 0000 0000 0000 1111
在这里插入图片描述
  由此可见，只有hash的低4位参与了运算。

为此，HashMap中，table的大小都是2的n次方，即使在构造函数中指定了table的大小，HashMap也会将该值扩大为距离它最近的2的整数次幂的值。

HashMap的属性及构造器

// 序列号
private static final long serialVersionUID = 362498820763181265L;

// 底层数组默认容量
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;

// 链表转为红黑树时的单链表元素的个数
static final int TREEIFY_THRESHOLD = 8;

// 红黑树转为链表的元素个数
static final int UNTREEIFY_THRESHOLD = 6;

// 红黑树最小容量
static final int MIN_TREEIFY_CAPACITY = 64;

// 底层存储keyy-value键值对的数组
transient Node<K,V>[] table;

// 记录元素个数
transient int size;

// 要调整大小的下一个大小值，即数组元素个数达到这个值是，就要进行扩容
int threshold;	

// 加载因子
final float loadFactor;

 // 没有指定时, 使用默认值
    // 即默认初始大小16, 默认负载因子 0.75
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
    
    // 指定初始大小, 但使用默认负载因子
    // 注意这里其实是调用了另一个构造函数
    public HashMap(int initialCapacity) {
        this(initialCapacity, 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;
        this.threshold = tableSizeFor(initialCapacity);
    }
    
    // 利用已经存在的map创建HashMap
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
        
}

我们可以看到，HashMap一共有4种构造器：

① 无参构造函数：给我们的加载因子一个默认值:0.75。

② 带有一个参数的构造函数：里面实际调用了带有两个参数的构造器函数

③ 带有两个参数的构造函数：int initialCapacity,float loadFactory，指定数组容量和加载因子。将我们给定的加载因子赋值，通过我们给定的容量，计算出thresold。

④ 带有Map的构造函数：利用已经存在的map创建HashMap。

通过上面的四个构造函数，我们发现，即使我们在构造函数中指定了底层数组的容量，这个容量也只会被用来计算thresold

this.threshold = tableSizeFor(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;
}

  tableSizeFor(int cap)方法，用于找到大于等于initialCapacity的最小的2的幂的数。当一个32位整数不为0时，32bit中至少有一个位置上为1。
  为什么要对cap进行减1操作呢？
      这是为了防止cap已经是2的幂，如果已经是2的幂，又没有执行减1操作，则执行完后面的无符号右移后，返回的capacity将是cap的2倍。
在这里插入图片描述
所以说，在HashMap中，构造器只涉及到loadFactor，thresold两个属性，其余的属性都没有涉及到。这也说明了，table容量的初始化，不是在构造函数中进行的，事实上，table初始化时，是在第一次put的时候。

HashMap中的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;
        // 如果数组为空，或者数组长度为0，则初始化数组。
        // 底层数组的初始化是在第一次put操作时进行的。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //使用(n-1)&hash的方法计算index。 
        //如果计算出的index位置上没有值时，则直接新创建一个节点，将该key-vaule封装到该节点中，存储到该位置上。
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 反之如果该位置上已经存在节点
        else {
            Node<K,V> e; K k;
            // 判断已存在的节点的key值与当前key是否相同。
            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);
            // 如果已经存在的节点的key值与当前key不相同
            else {
            	// 遍历链表或树
                for (int binCount = 0; ; ++binCount) {
                	// 如果当前位置只有一个元素，则通过尾插法，链在上一个节点的后面。
                    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相同的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;
    }

我们先看putVal的参数：

① hash： key的hash值。

② key，value ：要存储的键值对

③ onlyIfAbsent：这个参数用于决定待存储的key已经存在的情况下，要不要用新值覆盖原有的value，如果为true，则保持原有值，如果为false，则覆盖原有值。，从上面的调用来看，该值为false；说明当key已经存在时，会直接覆盖原有值。

总结：
① 在put之前，会判断table是否为空，说明table真正初始化没有发生在构造函数中，而是在第一次put时。

② 插入链表时，使用的是尾插法

③ 每次插入结束后，都会进行判断是否需要扩容。

④ 当一个存储桶上的链表元素超过8个时，并且数组长度超过64时，会进行该存储桶上的链表转为红黑树。

⑤ 如果数组长度没有超过64，存储桶上的链表中的元素个数超过8，不会转为红黑树，而是通过resize()扩容，然后再哈希的方式，寻找新的位置。
在这里插入图片描述

HashMap中的resize()扩容机制

 final Node<K,V>[] resize() {
 		// oldTab代表原数组
        Node<K,V>[] oldTab = table;
        // 判断原数组是否为null，如果为null，原数组容量赋为0。
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 如果原数组容量大于0
        if (oldCap > 0) {
        	// 判断原数组容量是否大于最大容量
            if (oldCap >= MAXIMUM_CAPACITY) {
            	// 如果大于，则将整数最大值赋给thresold。
                threshold = Integer.MAX_VALUE;
                // 返回原数组。（不进行扩容）
                return oldTab;
            }
            // 原数组容量小于定义的最大容量
            // 并且扩容后的数组容量小于最大容量 以及 原数组容量大于等于默认容量时
			// 按照2倍的方式扩容
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 新的thresold为原来的thresold的2倍
                newThr = oldThr << 1; // double threshold
        }
        // 原数组容量为0，但是oldThr大于0，即我们使用的一个参数的构造函数
        // 计算出了thresold，这个thresold是大于initialCapacity的最小的2的幂
        else if (oldThr > 0) // initial capacity was placed in threshold
            // 数组的容量就是我们之前已经在构造函数中计算好的thresold。
            newCap = oldThr;
        // 走到这里，说明，我们使用的是无参构造函数创建的HashMap对象
        else {               // zero initial threshold signifies using defaults
        	// 数组容量为我们的默认值16
            newCap = DEFAULT_INITIAL_CAPACITY;
            // 同时使用默认值初始化thresold。
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 计算指定initialCapacity情况下的 新的threshold。
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        // 创建一个新的数组
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
       
        table = newTab;
        
        // 将原数组得节点移至新数组。
		if (oldTab != null) {
			// 遍历原数组中的存储桶
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    // 如果存储桶上只有一个元素，则直接计算在新数组中的位置
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    // 如果存储桶上的节点是树型节点，则拆分树。
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    // 存储桶上的元素不止一个时：
                    else { // preserve order
                    	// 定义两个链表lo，li
                    	// loHead指向lo链表的头节点，loTail指向lo链表的尾节点
                        // 同理hiHead、hiTail。
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        // 循环遍历存储桶上的节点
                        do {
                            next = e.next;
                            // 如果该节点的hash与oldCap进行与操作为0，则插入lo链表
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            // 反之插入li链表
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                            // lo链表插入到新数组中的j位置上(即和原数组的位置相同)
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // li链表则插入到j+oldCap位置上
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        // 最后返回新数组
        return newTab;
    }

总结：
① 再进行resize()操作时，会先判断是否第一次使用table数组，如果不是，则按照2倍的方式扩容，计算新的thresold。

    ② 第一次使用table数组时，判断调用的无参构造还是有参构造。
       如果调用了无参构造，则table长度默认为16，thresold为16*0.75 = 12。
       如果调用有参构造，指定了initialCapacity，会计算出大于initialCapacity的最小的2的幂的数，通过这个值初始化table长度，并计算出thresold。