【源码剖析】HashMap和HashSet

最新推荐文章于 2022-04-04 11:59:00 发布
最新推荐文章于 2022-04-04 11:59:00 发布
阅读量115 收藏
点赞数
分类专栏： 源码解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Danerzz/article/details/109737285
版权

HashMap和HashSet

HashMap

概念特点

  • 数组+链表+红黑树（JDK 8）
  • 不重复，可以为null（唯一），重复的键会重写value值。
  • 线程不安全

构造方法

三个构造方法，分别是：

  • 无参构造
  • 带一个参数initialCapacity初始容量的构造
  • 带两个参数initialCapacity初始容量和负载因子的构造
    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);
    }

内部组成

  • size表示实际键值对的个数
  • table是一个Nodo类型的数组，称为哈希表，其中每个元素指向一个单向链表
  • modCount是map结构改变的次数
  • loadFactor是负载因子
transient Node<K,V>[] table;
transient int size;
transient int modCount;
int threshold;
final float loadFactor;

Node是一个内部类，如下：

  • key和value分别表示键和值
  • next指向下一个Node节点
  • hash是key的hash值
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

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

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

扩展策略

  • 添加第一个元素时，默认分配的大小时16，但size的扩展和threshold有关，并不是大于16扩展
  • threshold表示阈值，当键值对个数size大于等于threshold时考虑进行扩展。
  • threshold = loadFactor × table.length

方法执行

保存键值对 put()

Hashmap保存键值对的过程：

  • 如果是第一次保存，首先调用inflateTable方法给table分配实际的空间
  • 默认情况下，capacity的值为16，threshold会变为12，table会分配一个长度为16的Entry数组。接下来检查key是否为null，如果是，调用putForNullKey单独处理。key不为null情况下，调用hash方法计算key的hash值。
  • 基于key自身的hashCode方法返回值再进行一些位运算，增强随机性。有了hash值后调用indexFor方法，计算应该将键值对放到table的按个位置。
  • HashMap中，length为2的幂次方，h&(length-1)等同于求模运算h%length。找到保存位置i，table[i]指向一个单链表。接下来查找该键，比较时，先比较hash在比较equals。
  • 如果找到，修改Node节点中的value值，modCount++，如果没找到，调用addEntry方法在给定位置增加。
  • 如果空间够，则不需要resize，否则调用ctreateEntry添加。
  • 上述为jdk 7解释，下文代码为jdk 8代码。
    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;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            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);
                        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);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

查找方法 get()

  • 通过key找到计算索引，在哈希表中找到位置，检查第一个节点，如果是则返回，如果不是，遍历其后面的链表或者红黑树。
  • 如果是树，以树节点的方式遍历整棵树查找
  • 如果不是树，则说明是链表，以遍历链表的方式查找
  • 其余情况返回null。
    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;
    }

是否包含键

containkey方法逻辑与get类似

public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

是否包含值

查找是否包含值，需要对每个值进行遍历

  • 外循环哈希表
  • 内循环链表
public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
    	//遍历桶
        for (int i = 0; i < tab.length; ++i) {
        	//遍历桶中的每个节点元素
            for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;

删除键值对

  • 删除元素首先要找到元素在哈希表中的位置。
  • 如果是链表，进行链表遍历后删除元素；如果是红黑树，进行输的遍历后删除元素，进行平衡调节。
  • 当红黑树节点数小于6时，会转化为链表。
public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
     //(n - 1) & hash 找到元素在哈希表中的位置
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        //如果键的值与链表第一个节点相等，则将 node 指向该节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        //如果哈希表的节点存在下一个节点
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)//结点是否为红黑树
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);//找到需要删除的红黑树节点
            else {//结点为链表
                do {//遍历链表，找到待删除的节点
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
         //删除节点，并进行调节红黑树平衡
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

遍历元素

  • 获取key集合进行foreachmap.keySet()
  • 获取value集合进行foreachmap.values()
  • 获取key集合，遍历key集合，根据key找到响应valuemap.keySet()；map.get(key)
  • 获取Entry集合，遍历Entry
  • 获取迭代器

HashMap总结

  • 节点数组（哈希表）+链表+红黑树
  • 链表长度大于8转化为红黑树，小于6转化为链表
  • 允许key为null，但唯一
  • 线程不安全
  • 无序
  • 根据键保存和获取值效率高，O(1)

HashSet

概念特点

  • 无重复、不保证顺序
  • 排重（重复值不会覆盖）

构造方法

HashSet的构造方法主要就是调用了对应的HashMap的构造方法，如：

    public HashSet() {
        map = new HashMap<>();
    }
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

内部组成

HashSet相当于只有键，值都是相同的固定值，值定义为

private static final Object PRESENT = new Object();

扩展策略

同HashMap的拓展策略

方法执行

增加方法 add

调用map的增加方法

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

查找方法 contains

调用map的查找键的方法

public boolean contains(Object o) {
    return map.containsKey(o);
}

删除方法 remove

调用map的删除方法

public boolean remove(Object o) {
    return map.remove(o)==PRESENT;
}

遍历元素

迭代器返回map的迭代器

public Iterator<E> iterator() {
    return map.keySet().iterator();
}

HashSet总结

  1. 内部实现利用了HashMap
  2. 没有重复元素
  3. 无序
  4. 可以高效的添加、删除元素、判断元素是否存在，效率为 O(1)。
  5. 线程不安全
  6. 集合元素可以使null
张茂祯
关注
专栏目录
Java集合框架源码剖析：HashSet 和 HashMap
12-22
　之所以把HashSet和HashMap放在一起讲解，是因为二者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也是说HashSet里面有一个HashMap（适配器模式）。因此本文将重点分析HashMap。 　HashMap实现了Map...
HashMap源码剖析共10页.pdf.zip
10-29
《HashMap源码剖析》 HashMap是Java编程语言中一个非常重要的数据结构，它属于集合框架的一部分，提供了键值对（Key-Value）的存储方式。HashMap在内部使用了一个数组和链表来实现，实现了快速的查找、插入和删除...
HashSet 源码分析
MG
04-04 1623
HashSet 源码分析 Set类似于一个罐子，程序可以依次把多个对象“丢进”Set集合，而Set集合通常不能记住元素的添加顺序。 实际上Set就是Collection只是行为略有不同(Set不允许包含重复元素)。 Set 和和 List 接口一样, Set 接口也是 Collection 的子接口，因此，常用方法和 Collection 接口一样。 HashSet是Set接口的典型实现，大多数时候使用Set集合时就是使用这个实现类。HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找
剖析 HashMap 和 HashSet
sinat_41653656的博客
11-16 660
剖析 HashMap 和 HashSet1. 剖析 HashMap1.1 Map 接口1.2 HashMap1.3 HashMap 实现原理1.3.1 内部组成1.3.2 默认构造方法1.3.3 保存键值对1.3.4 查找方法1.3.5 根据键删除键值对1.3.6 遍历元素1.3 HashMap 总结 1. 剖析 HashMap 1.1 Map 接口 Map 有键和值的概念，一个键映射到一个值，Map 按照键存储和访问值，键不能重复，给同一个键重复赋值会覆盖原来的值。数组、Arr
Java HashSet和HashMap源码剖析
Alan_Xiang的博客
02-09 538
原文地址：http://www.cnblogs.com/CarpenterLee/p/5440428.html 总体介绍 之所以把HashSet和HashMap放在一起讲解，是因为二者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也就是说HashSet里面有一个HashMap（适配器模式）。因此本文将重点分析HashMap。 HashMap实现了Map接口，允许放入n
HashSet and HashMap源码剖析
欢迎光临
03-13 252
总体介绍 之所以把HashSet和HashMap放在一起讲解，是因为二者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也就是说HashSet里面有一个HashMap（适配器模式）。因此本文将重点分析HashMap。 HashMap实现了Map接口，允许放入null元素，除该类未实现同步外，其余跟Hashtable大致相同，跟TreeMap不同，该容器不保证元素顺序，根据需要该容器可能会...
Hashmap和hashSet
wangkai19960225的博客
02-10 323
2-10 晚11点开始讨论 有关hashset hashmap的知识点 注意：线程同步，两者区别，查询机制，映射机制，源码剖析 Map    Map是一种典型的名值对类型，它提供一种Key-Value对应保存的数据结构。我们通过Key值来访问对应的Value。和Java集合类里头其他的类不太一样，这个接口并没有继承Collection这接口。而其他的类或者接口不管是List, Set, Stack...
源码剖析——HashMap、HashTable、HashSet的区别
勤奋写代码的人
08-04 312
1、HashMap、HashTable 实际上是数组和链表的结合 2、HashMap、HashTable 不允许添加相同key，若添加了已经存在的key，则会以最新的替代原来的，并返回上次的value 3、HashMap允许添加key或value为null，HashTable不允许添加key或value为null 4、HashMap线程不安全，性能高，HashTable线程安全，方法中加s
java hashset 源码_Java集合HashSet源码剖析
weixin_34964950的博客
02-16 94
Java集合HashSet源码剖析白玉 IT哈哈 javapublic class HashSet extends AbstractSet implements Set, Cloneable, java.io.SerializableHashSet实现Set接口，内部维护一个HashMap实例变量。不保证顺序，容许null元素。对于基本的操做，如add，remove，contains，size，只...
Java集合框架HashSet和HashMap源码剖析
huangshulang1234的博客
03-30 194
Java集合框架HashSet和HashMap源码剖析 总体介绍 之所以把HashSet和HashMap放在一起讲解，是因为二者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也就是说HashSet里面有一个HashMap（适配器模式）。因此本文将重点分析HashMap。 HashMap实现了Map接口，允许放入null元素，除该类未实现同步
Java 集合框架 HashSet 和 HashMap 源码剖析
play_chess_ITmanito的博客
07-05 527
总体介绍 之所以把HashSet和HashMap放在一起讲解，是因为二者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也就是说HashSet里面有一个HashMap（适配器模式）。因此本文将重点分析HashMap。 HashMap实现了Map接口，允许放入null元素，除该类未实现同步外，其余跟Hashtable大致相同，跟TreeMap不同，该容器不保证元素顺序，根据需要该容器可能
JavaHashSet和HashMap源码剖析编程开发技术
11-22
在Java编程语言中，HashSet和HashMap是两种非常重要的集合类，它们都位于`java.util`包下，分别用于存储不重复元素的集合和键值对的数据结构。本篇技术文档将深入剖析这两类数据结构的源码，帮助开发者理解其内部...
pytz-2022.6-py2.py3-none-any.whl
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
VB程序实例-禁用IE[查看]菜单下[工具栏]中的子菜单.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
技术资料分享ZigBee-Specification（2007）非常好的技术资料.zip
11-03
技术资料分享ZigBee-Specification（2007）非常好的技术资料.zip
VB程序实例-房态状态管理.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
VB程序实例82_Foleder操作_建立删除文件.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
Screenshot_2024-11-03-14-05-43-43.jpg
11-03
Screenshot_2024-11-03-14-05-43-43.jpg
VB程序实例-SQL使用技巧-日期数据查询.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
hashmap和hashset
08-03
HashMap和HashSet是Java集合框架中的两个类。HashSet底层是通过HashMap实现的[1]。当我们向HashSet中添加元素时，HashSet会调用元素的hashCode方法来比较hash值，并根据hash值决定将元素放在对应的位置[2]。如果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值