HashMap与HashSet的存储实现

于 2020-03-13 16:02:49 发布
阅读量2.2k 收藏 2
点赞数
分类专栏： java 文章标签： java hashmap hash
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/oooo2316/article/details/104842703
版权
本文详细介绍了HashMap和HashSet的存储实现。HashMap在JDK1.8中使用位桶+链表/红黑树的方式，JDK1.6则是位桶+链表。初始化时，容量会调整为2的n次方。put操作通过hash值计算索引，插入或覆盖键值对；get操作则根据hash值查找键。HashSet基于HashMap实现，存储元素并拒绝重复。此外，还对比了HashMap与HashSet、Hashtable、LinkedHashMap和TreeMap的区别。

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

HashMap

HashMap在JDK1.8里发生了一点变化，我们先来说JDK1.6，搞懂1.6之后更容易理解1.8 。

HashMap的初始化

HashMap有三个构造函数：

  • HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
  • HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity（注），负载因子为 0.75 的 HashMap。
  • HashMap(int initialCapacity, float loadFactor)：以指定初始容量（注）、指定的负载因子创建一个 HashMap。

注：HashMap初始化时，容量并不是initialCapacity，而是大于initicalCapacity的最小的2的n次方的数，如 new HashMap(10)，容量会被设成16 。

构造函数主要做的事有：

  1. 判断 initicalCapacity，小于0抛 IllegalArgumentException ，大于最大容量时设为最大容量；

  2. 判断 loadFactor（负载因子），小于等于0抛异常；

  3. 计算initicalCapacity，也就是（注）里说的；

  4. 设置负载因子；

  5. 初始化数组。

源码为：

 // 以指定初始化容量、负载因子创建 HashMap 
 public HashMap(int initialCapacity, float loadFactor) 
 { 
	 // 初始容量不能为负数
	 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( 
		 loadFactor); 
	 // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。
	 int capacity = 1; 
	 while (capacity < initialCapacity) 
		 capacity <<= 1; 
	 this.loadFactor = loadFactor; 
	 // 设置容量极限等于容量 * 负载因子
	 threshold = (int)(capacity * loadFactor); 
	 // 初始化 table 数组
	 table = new Entry[capacity];
	 init(); 
 }

HashMap的数据结构

1.6中，HashMap采用 位桶+链表 的方式，也就是散列链表，来存储键值对对象Entry。

散列链表table是一个Entry数组，Entry可以看作是一个头插单链表，链表头存放在table中。

插入时，就是通过hash值计算元素要放在table数组的哪个位置，然后在这个位置对应的Entry链表上进行插入操作。

在这里插入图片描述

put操作

插入过程，大致过程为：

  1. 空键直接放到空键对应的值上；

  2. 计算hash值并获取hash值在table表中的索引；

  3. 在索引对应的Entry链表上查找键

  4. 覆盖Entry对象的值（找到相同键）或新建Entry对象（没有相同键）

具体流程如下：

在这里插入图片描述

原理知道了，再来看对应的代码，流程与上面是对应的

在这里插入图片描述

右边是一些实现细节，一个是hash值的计算，一个是获取hash值在table中的索引，一个是添加Ehtry对象的操作。注意，这里的hash值不是对象的hashcode，看流程图的第三步，是 hash(key.hashCode) 。hash()这个函数的计算是个纯粹的数学计算，就不多说了，来看indexFor()：

return h & (length - 1);

有人可能要问了，就这么一句，就能找到对应的索引位置？

这个地方巧妙在，它与HashMap的初始化和扩充联系了起来：

初始化时，table的初始大小一定是2的n次方；

扩充时，在右边第三个，addEntry方法内的最后，可以看到hashmap到达一定容量会扩充，且每次都是原来的二倍，这样，table的大小一定是2的n次方，对应的二进制值一定是 100...00 ，上面的 (length - 1) 一定是 11...11 ，那么其他数与 11...11 的 & 操作一定是 这个数 % 11...11 ，我们假设length = 16，length - 1 = 15，那么 int & (length - 1) 时：

101 & 1111 = 101	// 5 & 15 = 5
1111 & 1111 = 1111	// 15 & 15 = 15
10000 & 1111 = 0	// 16 & 15 = 0
10001 & 1111 = 1	// 17 & 15 = 1

这样就保证了计算出的索引值总是小于length。

再看addEntry()，有人可能又要问了，为什么是头插不是尾插？

我们假设hash对应的索引处还没有Entry对象放进来，table[bucketindex] == null，如果这时进行尾插，那么会报空指针异常，再判断是否为null又会增加操作。

如果头插，新对象指向旧对象，那么不管旧对象是不是null都可以插入成功，也无需加判空。

这里是put的源代码：

 public V put(K key, V value) { 
	 // 如果 key 为 null，调用 putForNullKey 方法进行处理
	 if (key == null) 
		 return putForNullKey(value); 
	 // 根据 key 的 keyCode 计算 Hash 值
	 int hash = hash(key.hashCode()); 
	 // 搜索指定 hash 值在对应 table 中的索引
 	 int i = indexFor(hash, table.length);
	 // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素
	 for (Entry<K,V> e = table[i]; e != null; e = e.next) { 
		 Object k; 
		 // 找到指定 key 与需要放入的 key 相等（hash 值相同
		 // 通过 equals 比较放回 true）
		 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 
			 V oldValue = e.value; 
			 e.value = value; 
			 e.recordAccess(this); 
			 return oldValue; 
		 } 
	 } 
	 // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry 
	 modCount++; 
	 // 将 key、value 添加到 i 索引处
	 addEntry(hash, key, value, i); 
	 return null; 
 }
get操作

理解了put操作，get操作就很简单了，找到hash值对应索引处的Entry链表，然后在链表里查找键就可以了。

性能选项

负载因子（loadFactor）默认值为0.75

  • 增大负载因子，使Entry数组在用了0.75时不扩容，而是让新来的对象继续插向已有链表，可以减少Entry数组所占空间，但会增加查询数据的时间（get和put都需要查询）
  • 减少负载因子，是Entry数组没到0.75时就扩充，可以让新来的对象去新开辟的空间，平均链表长度会变短，减少查询时间，但会增加内存使用

关心空间开销可以增大负载因子，关心时间开销可以减少负载因子。

如果HashMap要保存多个键值对，可以指定较大的初始化容量，减少数组resize次数，但过高可能会浪费空间。

1.8的新变化

我们在开头说1.6中HashMap采用 位桶+链表 的方式，而在JDK1.8中采用了 位桶+链表/红黑树 的方式，也是非线程安全的。当某个位桶的链表的长度达到某个阀值的时候，这个链表就被转换成红黑树。

看一下数据结构
在这里插入图片描述
可以看到多了个entrySet，这个是用来遍历返回所有键值对的，比遍历 keySet 再挨个获取值效率更高。

Node可以看作是原来的Entry，原先Entry类型的数组变成了Node类型，多出来了一个TreeNode，TreeNode继承自 LindedHashMap.Entry，这里作为红黑树的根节点存储在table中。

hash()函数也发生了变化

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

下面来看put的流程图（if警告）

在这里插入图片描述

上图虽然判断多，不过并不难理解，接下来看看对应的源码

在这里插入图片描述

这样看就比较复杂了，或许还不如直接看源码：

//put(K key,V value)函数
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;
    //如果table为空或者长度为0，则resize()
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //找到key值对应的槽并且是第一个，直接加入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K, V> e;
        K k;
        //第一个node的hash值即为要加入元素的hash
        if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k)))) {
            e = p;
        } else if (p instanceof TreeNode)//第一个节点是TreeNode，即tree-bin
            e = ((TreeNode<K, V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //不是TreeNode,即为链表,遍历链表
            for (int binCount = 0; ; ++binCount) {
                /*到达链表的尾端也没有找到key值相同的节点，
                 *则生成一个新的Node,并且判断链表的节点个数是不是到达转换成红黑树的上界
                 *达到，则转换成红黑树
                 */
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                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);
            //返回旧的value值
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

HashSet

HashSet是基于HashMap实现的，底层用HashMap来保存元素，看源码就知道了：

 public class HashSet<E> extends AbstractSet<E> 
     	implements Set<E>, Cloneable, java.io.Serializable { 
     
	 // 使用 HashMap 的 key 保存 HashSet 中所有元素
	 private transient HashMap<E,Object> map; 
	 // 定义一个虚拟的 Object 对象作为 HashMap 的 value 
	 private static final Object PRESENT = new Object(); 
	 ... 
	 // 初始化 HashSet，底层会初始化一个 HashMap 
	 public HashSet() { 
		 map = new HashMap<E,Object>(); 
	 } 
	 // 以指定的 initialCapacity、loadFactor 创建 HashSet 
	 // 其实就是以相应的参数创建 HashMap 
	 public HashSet(int initialCapacity, float loadFactor) { 
		 map = new HashMap<E,Object>(initialCapacity, loadFactor); 
	 } 
	 public HashSet(int initialCapacity) { 
		 map = new HashMap<E,Object>(initialCapacity); 
	 } 
	 HashSet(int initialCapacity, float loadFactor, boolean dummy) { 
		 map = new LinkedHashMap<E,Object>(initialCapacity 
			 , loadFactor); 
	 } 
	 // 调用 map 的 keySet 来返回所有的 key 
	 public Iterator<E> iterator() { 
		 return map.keySet().iterator(); 
	 } 
	 // 调用 HashMap 的 size() 方法返回 Entry 的数量，就得到该 Set 里元素的个数
	 public int size() { 
		 return map.size(); 
	 } 
	 // 调用 HashMap 的 isEmpty() 判断该 HashSet 是否为空，
	 // 当 HashMap 为空时，对应的 HashSet 也为空
	 public boolean isEmpty() { 
		 return map.isEmpty(); 
	 } 
	 // 调用 HashMap 的 containsKey 判断是否包含指定 key 
	 //HashSet 的所有元素就是通过 HashMap 的 key 来保存的
	 public boolean contains(Object o) { 
		 return map.containsKey(o); 
	 } 
	 // 将指定元素放入 HashSet 中，也就是将该元素作为 key 放入 HashMap 
	 public boolean add(E e) { 
		 return map.put(e, PRESENT) == null; 
	 } 
	 // 调用 HashMap 的 remove 方法删除指定 Entry，也就删除了 HashSet 中对应的元素
	 public boolean remove(Object o) { 
		 return map.remove(o)==PRESENT; 
	 } 
	 // 调用 Map 的 clear 方法清空所有 Entry，也就清空了 HashSet 中所有元素
	 public void clear() { 
		 map.clear(); 
	 } 
	 ... 
 }

小测试

class Name {
    private String first; 
    private String last; 
    
    public Name(String first, String last) {
        ...
    } 

    public boolean equals(Object o) {
        ...
    } 
}

public class HashSetTest {
    public static void main(String[] args) { 
        Set<Name> s = new HashSet<Name>();
        s.add(new Name("abc", "123"));
        System.out.println(s.contains(new Name("abc", "123")));
    }
}

输出是什么？




输出true，那么你忽略了一件事：HashSet是通过 hashCode()方法来初步判断对象是否相同的，然后才去判断 equals()，所以输出是false，如果想要输出true，需要重写 hashCode()。并且，用于计算hashCode的字段也要用于 equals() 的比较。

public int hashCode() { 
	return first.hashCode(); 
}

各种Hash与Map

HashMap与HashSet

虽然HashSet是基于HashMap实现的，不过还是有些区别：

  • HashSet是set的一个实现类,hashMap是Map的一个实现类,同时hashMap是hashTable的替代品
  • HashSet插入的是对象，目的是拒绝接受重复的对象，而HashMap插入的是Entry对象（键值对）。HashMap可以看作三个视图：key的Set，value的Collection，Entry的Set。 HashSet可以看作是HashMap的Entry Set视图。

HashMap与Hashtable

  • Hashtable继承自Dictionary类，HashMap继承自AbstractMap类，但都实现了Map接口

  • Hashtable的方法是Synchronize的，线程安全，HashMap默认非Synchronize，非线程安全

  • HashMap没有contains方法，改成containsKey和containsValue，Hashtable这仨都有，contains相当于containsValue

  • Hashtable的键和值都不允许null，HashMap允许有一个null键，值允许null。

    当get()返回null时，可能是HashMap中没有该键，也可能值就是null，所以HashMap不能由get()判断是否存在某个键，应该用containsKey()

  • Hashtable直接使用对象的hashCode，HashMap使用 hash(key.hashCode())

  • Hashtable初始大小为11，HashMap初始大小是16

  • Hashtable扩容大小为 2 * old + 1 ，HashMap为 2 * old

HashMap与LinkedHashMap

LinkedHashMap是HashMap的子类，相当于HashMap与LinkedList的结合体，每次put时，除了保存到对应的HashMap的位置外，还会加入到LinkedList的尾部，也就是说，可以通过从HashMap读取和遍历LinkedList来获取数据。

TreeMap

非线程安全

TreeMap实现SortMap接口，能够把它保存的记录根据键排序（默认升序）。当用Iterator遍历TreeMap时，得到的记录是排过序的。

TreeMap基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。

HashSet是通过HashMap实现的，TreeSet是通过TreeMap实现的。

构造方法：

TreeMap()：构建一个空的映像树

TreeMap(Map m)：构建一个映像树，并且添加映像m中所有元素

TreeMap(Comparator c)：构建一个映像树，并且使用特定的比较器对关键字进行排序

TreeMap(SortedMap s)：构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序





参考：

https://www.cnblogs.com/skywang12345/p/3310835.html（HashMap的UML图）

https://blog.youkuaiyun.com/u012926924/article/details/50452411（modCount的作用）

https://www.cnblogs.com/hfczgo/p/4033283.html（1.8中HashMap的变化）

https://blog.youkuaiyun.com/Jerome_s/article/details/45286881（1.6中HashMap的存储原理）

https://blog.youkuaiyun.com/wulunbi/article/details/51105028 (Hashtable HashMap HashSet的区别)

https://blog.youkuaiyun.com/justloveyou_/article/details/71713781（LinkedHashMap）

https://www.jianshu.com/p/57d3497ca720（TreeMap）

https://www.cnblogs.com/dreammyone/articles/9960400.html（通过entrySet遍历HashMap）

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值