HashMap 源码详解（1.7）

最新推荐文章于 2023-03-25 16:17:10 发布
最新推荐文章于 2023-03-25 16:17:10 发布
阅读量234 收藏
点赞数
分类专栏： java集合 文章标签： HashMap jdk1.7
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xu962336414/article/details/84307705
版权

一、HashMap初始化

	//创建一个无参的构造器，默认容量为16，加载因子0.75
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
    //创建一个指定容量的HashMap，默认加载因子为0.75
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    //创建一个指定容量，指定加载因子的HashMap
    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();
    }
    //创建一个指定参数为Map对象的HashMap
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);

        putAllForCreate(m);
    }

HashMap提供了四个构造方法，分别是无参数的构造器，包含一个参数（初始容量）的构造器，包含两个参数的构造器（初始容量，加载因子），和一个包含一个Map对象的构造器。HashMap初始容量为16，加载因子 0.75

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

static final float DEFAULT_LOAD_FACTOR = 0.75f;

二、Entry

我们知道HashMap 是以键值对的方式存储的，HashMap 内部实现了Entry,它是实现键值对存储的关键，Entry类包含一个key，value，一个外部引用的hash,以及Entry对象的引用，有点类似链表的结构。

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;//键
        V value;//值
        Entry<K,V> next;//下一节点
        int hash;//hash值

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
      }

三、table数组

    static final Entry<?,?>[] EMPTY_TABLE = {};//空的Entry对象

    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE; //空数组

每个键值对是通过Entry实现的，那么多个键值对元素是怎么存放的呢？ HashMap用EMPTY_TABLE表示一个空的数组，每个Entry都是放在一个table 数组中。由此可以看出，HashMap底层是通过链表+数组的方式元素。

如何创建数组

    /**
     * Inflates the table.
     */
    private void inflateTable(int toSize) {
        //这个方法之后返回 大于或者等于 2的几次幂
        int capacity = roundUpToPowerOf2(toSize);
		
		//默认容量16 *0.75=12 ，从12和最大容量之间取最小值，
		//因此这里threshold = 12，就是第一个需要扩容时的大小
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity]; //指定容量的Entry对象放到数组中
        initHashSeedAsNeeded(capacity);
    }
    private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

put方法中，当 数组table 为空时，通过inflateTable 初始化一个数组，数组默认容量为16，其实是通过roundUpToPowerOf2 返回大于等于最接近number的2的冪数，比如传入的为16，返回16，传入13，返回16，传入7，返回8。

四、增 put

在这里插入图片描述

    public V put(K key, V value) {
    	//如果数组为空，创建一个数组
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        //单独对key== null时的处理，其实就是去判断一下是否有空key，有的话，替换掉之前的value，
        //没有的话把key为null放到链表第一位				   
        if (key == null)
            return putForNullKey(value);
        //获取key的hash值
        int hash = hash(key);
        //通过hash值和数组长度，得到key所在的位置
        int i = indexFor(hash, table.length);
        //循环遍历链表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //都相等的话，新传入的value值替换老的value，可以看到key是不能重复的，重复就会被替换
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
		//记录修改次数，fail-fast机制，HashMap不是线程同步的
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

	//key == null,放到链表第一位，存在就替换掉value，不存在直接添加到首位
    private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }
    void addEntry(int hash, K key, V value, int bucketIndex) {
    	//当前大小 > 需要扩容的容量时候， 默认 threshold = 12 ，扩容扩大2倍
        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++;
    }
  1. 判断数组是否为空，为空的话就初始化一个默认容量为16的数组
  2. 判断传入的key是否为空，为空的话，就调用专门的插入null key的方法
  3. 拿到key的hash值，通过indexFor找到这个hash值所对应的数组的下标位置
  4. 循环遍历所在数组所在位置的链表，如果key的hash和传入key的hash相同且（key内存地址相等 或 equals方法相等），则意味着会更新在链表中的value值，并返回旧的value值。
  5. 如果上边的条件都没满足，执行到下边，就修改状态+1 ，然后通过createEntry 创建新的Entry对象

在hash的方法中，上边有一段这样的注释Note: Null keys always map to hash 0, thus index 0.

注意：空键始终映射到散列0，因此索引为0。我们在看putForNullKey这个方法，其实它是为了NULL值专门设置的，NULL值的hash始终为0，所以key为NULL的Entry对象肯定在数组的第0个位置。同样，如果找到则更新，没有找到则添加。

调用addEntry方法意味着要往这个数组链表中添加一个Entry，所以会在最开始判断已经存在的Entry数量是否超过了实际可容纳量(默认是16 *0.75 = 12)。如果超过了，则会调用resize方法将数组扩大两倍，注意在扩大之后会对已经存入的Entry进行重排，原因是当初存入时IndexFor方法与数组长度有关系。接着会调用createEntry方法。

createEntry方法很简单，就是将原本在数组中存放的链表头置入到新的Entry之后，将新的Entry放入数组中。从这里我们可以看出HashMap不保证顺序问题。
在这里插入图片描述

五、查 get方法,contains方法

    public V get(Object key) {
    	//HashMap 对key 为null的时候，都有一个专门的处理方法
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);
		//entry不为空的时候，返回value
        return null == entry ? null : entry.getValue();
    }

    private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }
    
    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {//长度为0返回null
            return null;
        }

        int hash = (key == null) ? 0 : hash(key);//获得key的hash值，为null时hash==0
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {//hash和数组长度获取对应的索引位置，再得到指定位置的entry
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }
  1. 首先判断传入的key 是否为null，如果是null直接调用getForNullKey；
  2. getForNullKey 其实类似put放入null key的方法，这个方法也是专门处理key 为 null的情况，当map不为空的时候，直接取数组中的第一个元素 table[0]，然后它的value
  3. 当key不是null的时候，就用去Entry中取值，通过getEntry方法，返回一个Entry对象
  4. getEntry方法依旧是，当map不是空的时候，通过传入key的hash值,然后indexFor将hash值转换为key所在的位置，然后拿到指定位置的entry对象，再去比较key的hash和传入key的hash相同且（key内存地址相等 或 equals方法相等）
  5. 最后，通过一个三元运算符，如果entry不为null，返回entry指定key对应的value值，否则返回null。

contains方法 ，直接调用的getEntry方法。

六、删除 remove

    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    final Entry<K,V> removeEntryForKey(Object key) {
        if (size == 0) {
            return null;
        }
         // 依旧是根据key算hash值再根据hash值和数组长度算出索引值，如果key是null，则索引就是0
        int hash = (key == null) ? 0 : hash(key);
        int i = indexFor(hash, table.length);
        // prey是该索引位置的链表的上一个节点，当前节点e,下一个节点next
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;
		// 开始遍历链表
        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            //这里类似get，put方法  如果各种都相等，那么就认为找到了给定的key对应的entry
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                // 修改次数modCount加1，key-value数量size减1
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                  // 将上一个节点prev的next指向当前节点的next，即跳过了当前节点
                // 此时当前节点没有任何引用指向，它在程序结束之后就会被gc回收
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }
  1. HashMap是一个数组与链表的复合结构，主要部分是Entry,通过对key的hash确定数组索引，通过hash值和equals方法比较key进行put。
  2. 计算数组索引时，是通过hash&(length-1)的方法进行计算的，效率大大高于取模。此时，要保证数组的length为2的整数次幂，这样能减少hash冲突，使元素散列均匀。
  3. HashMap的默认初始容量为16，加载因子为0.75,当达到容量*加载因子时会调用resize()进行扩容，扩容大小为一倍。扩容操作需要将数组复制，重新计算每个元素位置，十分消耗性能，要尽量避免扩容操作。
  4. HashMap是无序的，允许空值空键，但不允许重复的key,所以只能有一个null key
Sean_徐
关注
专栏目录
HashMap容量的初始化实现
qf2019的博客
07-26 212
HashMap使用HashMap(int initialCapacity)对集合进行初始化。 在默认的情况下，HashMap的容量是16。但是如果用户通过构造函数指定了一个数字作为容量，那么Hash会选择大于该数字的第一个2的幂作为容量。比如如果指定了3，则容量是4；如果指定了7，则容量是8；如果指定了9，则容量是16。 为什么要设置HashMap的初始化容量 下面我们通过具体的代码来了解下为什么会这么建议。 我们先来写一段代码在JDK1.7的环境下运行，来分别测试下，在不指定初始化容量和指定初始化容量的情
HashMap1.7源码详解
最新发布
wk_java_1619的博客
12-19 526
本文主要分析HashMap类的源码。
HashMap 加载因子
chentianqin的博客
02-23 494
HashMap 加载因子
hashMap底层实现解析(负载因子0.75,初始容量16,键不重复)
xx12321q的博客
03-07 692
目录 HashMap 为什么负载因子默认0.75呢? 为什么初始容量设置为16呢 ? HashMap 我们知道 , hashMap是双列集合 , 存储的是键值对 , 键不能重复,值可以重复 , 是Map接口下面的实现类 , 底层采用哈希表+链表+红黑树实现 ,另外哈希表默认长度16,负载因子0.75, 扩容2倍,链表长度为8自动转为红黑树等等 , 接着来一一解释它们 我们先来了解 hashMap 的底层到底是怎样去存储元素的, 如下图 如图所...
HashMap底层实现和原理（源码解析）
wJulio的博客
06-02 625
一、先来熟悉一下我们常用的HashMap 1、概述 HashMap基于Map接口实现，元素以键值对的方式存储，并且允许使用null 建和null 值， 因为key不允许重复，因此只能有一个键为null,另外HashMap不能保证放入元素的顺序，它是无序的，和放入的顺序并不能相同。HashMap是线程不安全的。 2、继承关系 public class HashMap<K,V>extends AbstractMap<K,V> implements Map&lt
hashmap详细剖析
qq_40847791的博客
06-10 274
确定hash桶数组的索引位置 我们当然希望这个HashMap里面的元素位置尽量分布均匀些，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，不用遍历链表，大大优化了查询的效率。HashMap定位数组索引位置，直接决定了hash方法的离散性能。先看看源码的实现(方法一+方法二): 方法一： static final int hash(Object key) { //jdk1.8 & jdk1.7 int h;
HashMap详解以及1.7和1.8区别
JavaTeachers的博客
04-19 377
HashMap 存储结构 hashMap的存储结构， 1.7：使用的是Entry数组+链表的形式 1.8：使用的是Node数组+链表+红黑树 定位数组索引 不管是put还是get，定位到哈希桶数组都是非常关键的一步。 HashMap定位数组索引位置，直接决定了hash方法的离散性能。先看看源码的实现(方法一+方法二): 方法一： static final int hash(Object key) { //jdk1.8 & jdk1.7 int h; //
【java】HashMap1.7源码详解
weixin_43148189的博客
12-17 773
前言 Hashmap是java api中一个非常强大的工具类，所以剖析它的源码就显得很有必要了；强调，本篇博文面向的是熟知Hashmap基本使用的编程者。 数据结构 在jdk1.7中Hashmap的基本数据结构是数组+链表的形式。 使用过Hashmap的同学都知道，它可以保存一对<key, value>，所以又是怎么放进数组的呢？答案是，在Hashmap中有一个内部类Entry，每添...
HashMap源码详解(JDK1.7&1.8)
萌萌的PP博客
04-10 900
JDK1.7HashMap源码详解，JDK1.8HashMap源码详解，HashMap源码底层实现！
jdk1.7HashMap并发扩容发生死循环源码详解
MrArgus的博客
03-25 343
jdk1.7HashMap并发扩容发生死循环源码详解
hashMap中的get方法
程序员养成日记
03-29 1万+
HashMap的get方法的实现，其判断标准是通过hashCode和equals方法。 /** * Returns the value to which the specified key is mapped, * or {@code null} if this map contains no mapping for the key. * * <p...
认真研究HashMap的读取和存放操作步骤
小小默：进无止境
10-11 1340
# 【1】数据结构 ## ① jdk1.7 JDK1.8 之前 HashMap 由 **数组+链表** 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（`“拉链法”`解决冲突）。 也就是说创建一个链表数组，数组中每一格就是一个链表。 ![在这里插入图片描述](https://img-blog.csdnimg.cn/b631b22b925340faab628ac1e9aa2e6b.png) ## ② jdk1.8 JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度
JAVA Map 之元素定位，冲突碰撞
weixin_30500105的博客
10-23 142
基本特性： 维持健值对的集合接口，健不可以重复，每一个健只能映射到一个值。 Map替代了原来的虚拟类Directory。 Map提供了三种集合视角，keys（KeySet），values（Values），entries（key-value）（EntrySet），Map元素的顺序体现于遍历器返回的Map元素顺序。 需要注意的是，不可以用可变的元素作Map的健，这会影响到equals对键值的...
java中hashmap的实现原理与底层数据结构
热门推荐
技术小白的博客
05-25 8万+
Hashmap是java面试中经常遇到的面试题，大部分都会问其底层原理与实现，本人也是被这道题问惨了，为了能够温故而知新，特地写了这个博客，以便时时学习。 Hash结构 HashMap根据名称可知，其实现方法与Hash表有密切关系。在讨论哈希表之前，我们先大概了解下其他数据结构在新增，查找等基础操作执行性能。 数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给...
二、Jdk1.7和1.8中HashMap数据结构及源码分析
不吃_花椒的博客
09-27 1005
导读 上篇文章（一、深入理解-Java集合初篇 ）中我们对Java的集合体系进行一个简单的分析，本篇我们我们将针对Java集合体系中的HashMap做详细介绍。 简单介绍 JDK1.7—》哈希表，链表 JDK1.8—》哈希表，链表，红黑树— JDK1.8之后，当链表长度超过8使用红黑树。 非线程安全 0.75的负载因子，扩容必须为原来的两倍。 默认大小为16，传入的初始大小必须为2的幂次方的值，如果不为也会变为2的幂次方的值。 根据HashCode存储数据。 JDK1.7-HashMap数据结构—》数
[Map]-3-关于HashMap容量的初始化，还有这么多学问
Franco的博客
05-31 5599
为什么要设置HashMap的初始化容量我们之前提到过，《阿里巴巴Java开发手册》中建议我们设置HashMap的初始化容量。那么，为什么要这么建议？你有想过没有。我们先来写一段代码在JDK 1.7 （jdk1.7.0_79）下面来分别测试下，在不指定初始化容量和指定初始化容量的情况下性能情况如何。（jdk 8 结果会有所不同，我会在后面的文章中分析）public static void main(...
java容器源码分析(四)——HashMap
weixin_33953249的博客
12-17 81
2019独角兽企业重金招聘Python工程师标准>>> ...
HashMap底层原理
任意门的博客
10-28 1340
常见的数据结构及特点 1.数组结构 特点：存储区间连续、内存占用严重、空间复杂度大 优点：随机读取和修改效率高，原因是数组是连续的（随机访问性强，查找速度快，可以直接根据下标取出） 确定：插入和删除数据效率低，因插入数据，这个位置后面的数据在内存中都要往后移动，且大小固定不易动态扩展。 2.链表结构 特点：存储区间离散、占用内存宽松、空间复杂度小 优点：插入删除速度快，内存利用率高，没有固定大小，扩展灵活 缺点：不能随机查找，每次都是从第一个开始遍历（查询效
基于源码(jdk1.7)对HashMap的get()和put()的小结
不善言谈者
01-27 5610
HashMap的概述 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collecti
hashmap源码详解
06-09
以下是HashMap源码的详细解释： HashMap内部是由一个数组和链表组成的，数组的每个元素称为桶，每个桶存储一个链表（可能为空），链表中的每个节点都是一个键值对（key-value pair）。 以下是HashMap的主要属性： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值