HashMap源码【jdk1.7】

最新推荐文章于 2021-11-09 15:12:22 发布

xiaoyaowuchen

最新推荐文章于 2021-11-09 15:12:22 发布

阅读量187

点赞数 1

分类专栏：开发语言文章标签： java jdk源码

本文链接：https://blog.csdn.net/u010704408/article/details/82627751

版权

开发语言专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章内容如有错误或论述不完善的地方，欢迎大家指点，让我们共同进步。 &( ^_^ )

1、HashMap介绍

HashMap 是一个存储key-value的容器，它使用数组+链表（1.8链表根据存储个数会转变为红黑树）的方式来存储数据，这种方式也是为了避免hash指针碰撞。

HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。此外，HashMap中的映射不是有序的。

他有两个参数影响其性能：初始容量和加载因子。默认初始容量是16，加载因子是0.75。容量是哈希表中桶(Entry数组)的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，通过调用 resize 方法将容量翻倍。

2、API介绍

2.1 继承关系

HashMap 继承抽象类AbstractMap ，实现Map、Cloneable（克隆）、Serializable（序列化）接口；

这里写图片描述

2.2 构造函数

方法	描述
HashMap()	构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity)	构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
HashMap(int initialCapacity, float loadFactor)	构造一个带指定初始容量和加载因子的空 HashMap。
HashMap(Map m)	构造一个映射关系与指定 Map 相同的新 HashMap

2.3 属性

// 默认的初始容量是16，必须是2的幂。
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 存储数据的Entry数组，长度是2的幂。
// HashMap是采用拉链法实现的，每一个Entry本质上是一个单向链表
transient Entry<K,V>[] table;
// HashMap的大小，它是HashMap保存的键值对的数量
transient int size;
// HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）
int threshold;
// 加载因子实际大小
final float loadFactor;
// HashMap结构修改的次数【结构-改变映射数量】
transient volatile int modCount;
//此映射中包含的键 - 值映射的数量。
transient int size;
//表示是否要对字符串键的HashMap使用备选哈希函数。
transient boolean useAltHashing;

2.4 方法

略

3、hashcode 和 hash算法

3.1 位运算相关知识

在Java中，所有数据的表示方式都是以补码形式来表示，可以解决0存储的问题，可以把减法视为加法运算。

正数：原码、反码、补码相同
负数：正数原码–符号位变为1，反码–除符号位外其余位取反，补码–反码加1

位运算

按位与 &：两个补码的数一一对应，对应位置的数都为1，结果为1，否则为0；
按位或 |：两个补码的数一一对应，对应位置的数至少一位为1，结果为1,否则为0；
按位异或 ^：两个补码的数一一对应，对应位置的数一个为1、一个为0，结果为1，否则为0；
按位取反～：补码中0变成1、1变成0；
左移运算符<< : 将参数的补码向左边移动指定的位数，低位补0；
- 左移相当于乘法,符号位是不移动的，快速计算：参数*2^位移个数
“有符号”右移运算符>>：将参数的补码向右边移动指定的位数。当值为正时，在高位补0，值为负，则在高位补1.
- 快速计算-正数：参数 / 2 ^位移个数，如8<<1 = 8/2^1=4、8<<3 = 8/2^3=1，有负数舍弃掉；
- 快速计算-负数：参数 * 2 ^位移个数，如-9<<3 = -9*2^3=2、-23<<3 = -23*2^3=31，有余数就进一位（无论余数是多少）
无符号”右移运算符 >>>：将参数的补码向右边移动指定的位数，忽略符号位，空位以0补齐。
- 快速计算-正数：同 >> 的正数运行；
- 快速计算-负数：规律待找寻

3.2 计算int值的32位补码

/**
 * 计算给定的int值的32位补码
 * @param numerical 整数数值
 */
public static void intCoding(int numerical){
   System.out.print(numerical+"的补码是：");
   for(int i=0;i<32;i++){
      int t = (numerical & 0x80000000 >>>i)>>>(31-i);
      System.out.print(t);
   }
 }

3.2 hashcode算法

put方法中有以下两个方法：

 int hash = hash(key); //获取key的hashCode
 int i = indexFor(hash, table.length); //对key的hashCode取模计算数组下标

hash方法内部使用了大量的位移和异或操作：
主要用途是打散key.hashCode()返回值中1所在的位置，也就是让返回值补码中的1分散的均匀些；原因是取模利用“按位与”来实现，因此当key.hashCode中1都分布在高位0分布在低位，而另一个值的分布相反时，那结果会相当美丽（结果都是0），简单的说就是避免取模后大量出现0。

indexFor方法求的是数组下标（hashMap结构是：数组+链表），该方法需要尽量保障数据的分散，因此选择“取模”来计算下标。但在java中取模和除法是消耗较大的操作，而“按位与”相对来说消耗要少很多。

static int indexFor(int h, int length) {
   return h & (length-1);   //length是当前容量
}

为什么让key的hash值与 hashMap的容量-1做按位与操作？
在源码中length是当前容量，按规则容量用于是一个偶数，让一个偶数与 h按位与，得到的都是偶数下标，会浪费近一半的空间，而奇数就不会。具体原因是偶数的补码最后一位是0，因此不管h的最后一位是什么，结果都为0，所以(length-1)为奇数可以保证结果的最后一位是1，这样与h按位与，最后一位的结果可能是1也可能是0（因为h的最后一份是1or0）。

4、源码解析

4.1 模型

hashMap的一个数组+链表的模型结构，在源码中结构如下：

和key映射的数组

transient Entry<K,V>[] table;

链表中的数据节点

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;        //key值

    V value;            //value值

    Entry<K,V> next;    //下一个节点 

    int hash;       //key的hash值

    //创建一个新的Entry
    //输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"
    Entry(int h, K k, V v, Entry<K,V> n)
    public final K getKey()
    public final V getValue() 
    //更新value的值，返回旧值
    public final V setValue(V newValue)
    //判断两个Entry是否相等
    //若两个Entry的“key”和“value”都相等，则返回true,否则，返回false
    public final boolean equals(Object o) 
    //key和value按位异或，重写hashCode()
    public final int hashCode()
    public final String toString()
    //当向HashMap中添加元素时，绘调用recordAccess()，这里不做任何处理
    void recordAccess(HashMap<K,V> m) 
    //当从HashMap中删除元素时，绘调用recordRemoval()，这里不做任何处理
    void recordRemoval(HashMap<K,V> m)
}

从代码中，可以看出 Entry 实际上就是一个单向链表。这也是为什么我们说HashMap是通过拉链法解决哈希冲突的。

Entry 实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数。这些都是基本的读取/修改key、value值的函数。

4.2 hashMap的构造函数

hashMap共有4个构造函数，但最终调用的都是一个构造函数

/**
 * @param  initialCapacity 容量大小
 * @param  loadFactor      加载因子
 */ 
public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        // HashMap的最大容量只能是MAXIMUM_CAPACITY
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
        // 保证容器大小是2的幂
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;
        // 设置“加载因子”
        this.loadFactor = loadFactor;
        // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        // 创建Entry数组，用来保存数据
        table = new Entry[capacity];
        //计算是否对字符串键的HashMap使用备选哈希函数
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        //在hashMap里是空方法，需要子类去实现
        init();
   }

4.3 put 方法

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        //求key的hash值
        int hash = hash(key);
        //对key的hash值 和 容器长度-1 取模求得下标（table的下标）==尽量打散下标的分布
        int i = indexFor(hash, table.length);
        //key值hash后的下标索引对应值非null，进行遍历
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // hash值相等 并且 key值相等，执行更新操作，并返回旧值结束程序
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        } 
        //更新 ashMap结构修改的次数【结构-改变映射数量】
        modCount++;
        //链表最前面插入一个新的值
        addEntry(hash, key, value, i);
        return null;
    }

容量的扩容在putAll方法里有扩容逻辑；

4.4 get方法

 public V get(Object key) {
        if (key == null)
            return getForNullKey();
        //根据key获取对应的Entry
        Entry<K,V> entry = getEntry(key);
        //null返回null，非null返回value
        return null == entry ? null : entry.getValue();
    }

    //根据key获取对应的Entry
    final Entry<K,V> getEntry(Object key) {
        //获取key的hash值
        int hash = (key == null) ? 0 : hash(key);
        //取模获取key的下标，从table表中得到链表
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            // hash值相同 并且 key相同，说明找到对应的节点，返回
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        //没有找到返回空
        return null;
    }

4.5 remove 方法

public V remove(Object key) {
        //移除指定key对应的Entry
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

 final Entry<K,V> removeEntryForKey(Object key) {
        //获取key的hash值
        int hash = (key == null) ? 0 : hash(key);
        //获取key对应的下标
        int i = indexFor(hash, table.length);
        //初始化等于链表的表头，也代表上一个节点
        Entry<K,V> prev = table[i];
        //初始化等于链表的表头，代表当前节点
        Entry<K,V> e = prev;

        while (e != null) {
            //当前节点的下一个节点
            Entry<K,V> next = e.next;
            Object k;
            //当前节点的hash和给定key的哈市相等 并且  key值相等，说明找到要删除的数据
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                //HashMap结构修改的次数加1【结构-改变映射数量】
                modCount++;
                //键值映射数量减1
                size--;
                if (prev == e) //第一次循环
                    table[i] = next; //链表从next开始
                else
                    prev.next = next; //跳过当前节点
                //空操作
                e.recordRemoval(this);
                //返回删除的数值
                return e;
            }
            prev = e;
            e = next;
        }
        //这里返回的永远是null
        return e;
    }

4.5 putAll 方法

public void putAll(Map<? extends K, ? extends V> m) {
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;

        /*
         * 给定map的实际容量 大于 当前Map的阈值在进行扩容，
         *   为什么不是(numKeysToBeAdded+table.length)>threshold的时候在去扩容，因为
         *   考虑给定的map和原map里的key有相同的可能，避免扩容过大浪费空间
         */
        if (numKeysToBeAdded > threshold) {
            // targetCapacity = 给定map当下的最大容量
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            // 给定map当下的最大容量 不能超过 程序规定的Map最大容量
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            //当前map的容量
            int newCapacity = table.length;
            //当前map的容量值 小于 给定map当下的最大容量，通过左移改变当前map的容量，每次扩大两倍
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            //扩容后的当前map的容量值 大于 当前map的容量，进行实质的扩容
            if (newCapacity > table.length)
                resize(newCapacity);
        }
        //通过put的方法把给定map里的值一个一个的添加到当前map里
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }

4.6 resize 方法进行扩容

 //newCapacity 给定的新表的容量
 void resize(int newCapacity) {
        //新建一个变量，命名为旧表 并 指向当前的表
        Entry[] oldTable = table;
        //获取旧表的容量
        int oldCapacity = oldTable.length;
        //旧表的容量 等于 程序规定的Map最大容量（只能等于不可能超过）
        if (oldCapacity == MAXIMUM_CAPACITY) {
            // 当前map的阈值 等于 int的最大值，并返回，也就是不扩容了
            threshold = Integer.MAX_VALUE;
            return;
        }
        //初始化一个新表，容量给定的容量（进行过扩容后的容量）
        Entry[] newTable = new Entry[newCapacity];
        //计算是否需要对键重新进行哈希码的计算
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;
        //旧表中的值一个一个的都放入到新表中（数组迁移）；
        //新表的容量改变了，重新计算后获取到的下标也发生了改变
        transfer(newTable, rehash);
        //新表 替换 当前map的表
        table = newTable;
        //重新进行HashMap的阈值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

putAll方法调用resize，调用方式请看【4.5 putAll 方法】的分析；
put方法也会调用resize，在put方法里新的容量计算方式很简单：2 * table.length；

xiaoyaowuchen

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
HashMap源码【jdk1.7】

欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦：Markdown和扩展Markdown简洁的语法代码块高亮图片链接和图片上传LaTex数学公式UML序列图和流程图离线写博客导入导出Markdown文件丰富的快捷键快捷键加粗 Ctrl + B 斜体 Ctrl + I...
复制链接

扫一扫