首页手记 Java源码分析：HashMap 1.8...

Java源码分析：HashMap 1.8 及与HashMap1.7比较

标签：

Java

前言

今天，我将通过源码分析HashMap 1.8 ，从而讲解HashMap 1.8 相对于 HashMap 1.7 的更新内容，希望你们会喜欢。

示意图.png

1. 简介

类定义

public class HashMap<K,V>         extends AbstractMap<K,V> 
         implements Map<K,V>, Cloneable, Serializable

主要简介

示意图.png
HashMap 的实现在 JDK 1.7 和 JDK 1.8 差别较大
今天，我将对照 JDK 1.7的源码，在此基础上讲解 JDK 1.8 中 HashMap 的源码解析

2. 数据结构：引入了红黑树

2.1 主要介绍

示意图

关于红黑树的简介

示意图

更加具体的了解，请：点击阅读文章

2.2 存储流程

为了让大家有个感性的认识，只是简单的画出存储流程，更加详细 & 具体的存储流程会在下面源码分析中给出

示意图

2.3 数组元素 & 链表节点的实现类

HashMap中的数组元素 & 链表节点采用 Node类实现

与 JDK 1.7 的对比（Entry类），仅仅只是换了名字

该类的源码分析如下

/** 
  * Node  = HashMap的内部类，实现了Map.Entry接口，本质是 = 一个映射(键值对)
  * 实现了getKey()、getValue()、equals(Object o)和hashCode()等方法
  **/  

  static class Node<K,V> implements Map.Entry<K,V> {        final int hash; // 哈希值，HashMap根据该值确定记录的位置
        final K key; // key
        V value; // 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 V setValue(V newValue) {
            V oldValue = value;
            value = newValue;            return oldValue;
        }      /** 
        * hashCode（） 
        */
        public final int hashCode() {            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }      /** 
        * equals（）
        * 作用：判断2个Entry是否相等，必须key和value都相等，才返回true  
        */
        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;
        }
    }

2.4 红黑树节点实现类

HashMap中的红黑树节点采用 TreeNode 类实现

/**
  * 红黑树节点 实现类：继承自LinkedHashMap.Entry<K,V>类
  */
  static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {  

    // 属性 = 父节点、左子树、右子树、删除辅助节点 + 颜色
    TreeNode<K,V> parent;  
    TreeNode<K,V> left;   
    TreeNode<K,V> right;
    TreeNode<K,V> prev;   
    boolean red;   

    // 构造函数
    TreeNode(int hash, K key, V val, Node<K,V> next) {  
        super(hash, key, val, next);  
    }  
  
    // 返回当前节点的根节点  
    final TreeNode<K,V> root() {  
        for (TreeNode<K,V> r = this, p;;) {  
            if ((p = r.parent) == null)  
                return r;  
            r = p;  
        }  
    }

3. 具体使用

3.1 主要使用API（方法、函数）

V get(Object key); // 获得指定键的值V put(K key, V value);  // 添加键值对void putAll(Map<? extends K, ? extends V> m);  // 将指定Map中的键值对 复制到 此Map中V remove(Object key);  // 删除该键值对boolean containsKey(Object key); // 判断是否存在该键的键值对；是 则返回trueboolean containsValue(Object value);  // 判断是否存在该值的键值对；是 则返回true
 Set<K> keySet();  // 单独抽取key序列，将所有key生成一个SetCollection<V> values();  // 单独value序列，将所有value生成一个Collectionvoid clear(); // 清除哈希表中的所有键值对int size();  // 返回哈希表中所有 键值对的数量 = 数组中的键值对 + 链表中的键值对boolean isEmpty(); // 判断HashMap是否为空；size == 0时 表示为 空

3.2 使用流程

在具体使用时，主要流程是：

声明1个 HashMap的对象
向 HashMap 添加数据（成对放入键 - 值对）
获取 HashMap 的某个数据
获取 HashMap 的全部数据：遍历HashMap

示例代码

import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;

public class HashMapTest {

    public static void main(String[] args) {      /**
        * 1. 声明1个 HashMap的对象
        */
        Map<String, Integer> map = new HashMap<String, Integer>();      /**
        * 2. 向HashMap添加数据（成对 放入 键 - 值对）
        */
        map.put("Android", 1);
        map.put("Java", 2);
        map.put("iOS", 3);
        map.put("数据挖掘", 4);
        map.put("产品经理", 5);       /**
        * 3. 获取 HashMap 的某个数据
        */
        System.out.println("key = 产品经理时的值为：" + map.get("产品经理"));      /**
        * 4. 获取 HashMap 的全部数据：遍历HashMap
        * 核心思想：
        * 步骤1：获得key-value对（Entry） 或 key 或 value的Set集合
        * 步骤2：遍历上述Set集合(使用for循环 、 迭代器（Iterator）均可)
        * 方法共有3种：分别针对 key-value对（Entry） 或 key 或 value
        */

        // 方法1：获得key-value的Set集合 再遍历
        System.out.println("方法1");        // 1. 获得key-value对（Entry）的Set集合
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();        // 2. 遍历Set集合，从而获取key-value
        // 2.1 通过for循环
        for(Map.Entry<String, Integer> entry : entrySet){
            System.out.print(entry.getKey());
            System.out.println(entry.getValue());
        }
        System.out.println("----------");        // 2.2 通过迭代器：先获得key-value对（Entry）的Iterator，再循环遍历
        Iterator iter1 = entrySet.iterator();        while (iter1.hasNext()) {            // 遍历时，需先获取entry，再分别获取key、value
            Map.Entry entry = (Map.Entry) iter1.next();
            System.out.print((String) entry.getKey());
            System.out.println((Integer) entry.getValue());
        }        // 方法2：获得key的Set集合 再遍历
        System.out.println("方法2");        // 1. 获得key的Set集合
        Set<String> keySet = map.keySet();        // 2. 遍历Set集合，从而获取key，再获取value
        // 2.1 通过for循环
        for(String key : keySet){
            System.out.print(key);
            System.out.println(map.get(key));
        }

        System.out.println("----------");        // 2.2 通过迭代器：先获得key的Iterator，再循环遍历
        Iterator iter2 = keySet.iterator();        String key = null;        while (iter2.hasNext()) {
            key = (String)iter2.next();
            System.out.print(key);
            System.out.println(map.get(key));
        }        // 方法3：获得value的Set集合 再遍历
        System.out.println("方法3");        // 1. 获得value的Set集合
        Collection valueSet = map.values();        // 2. 遍历Set集合，从而获取value
        // 2.1 获得values 的Iterator
        Iterator iter3 = valueSet.iterator();        // 2.2 通过遍历，直接获取value
        while (iter3.hasNext()) {
            System.out.println(iter3.next());
        }

    }


}// 注：对于遍历方式，推荐使用针对 key-value对（Entry）的方式：效率高// 原因：
   // 1. 对于 遍历keySet 、valueSet，实质上 = 遍历了2次：1 = 转为 iterator 迭代器遍历、2 = 从 HashMap 中取出 key 的 value 操作（通过 key 值 hashCode 和 equals 索引）
   // 2. 对于 遍历 entrySet ，实质 = 遍历了1次 = 获取存储实体Entry（存储了key 和 value ）

运行结果

方法1
Java2
iOS3
数据挖掘4
Android1
产品经理5
----------
Java2
iOS3
数据挖掘4
Android1
产品经理5
方法2
Java2
iOS3
数据挖掘4
Android1
产品经理5
----------
Java2
iOS3
数据挖掘4
Android1
产品经理5
方法3
2
3
4
1
5

下面，我们按照上述的使用过程，对一个个步骤进行源码解析

4. 基础知识：HashMap中的重要参数（变量）

在进行真正的源码分析前，先讲解HashMap中的重要参数（变量）
HashMap中的主要参数同 JDK 1.7 ，即：容量、加载因子、扩容阈值
但由于数据结构中引入了红黑树，故加入了与红黑树相关的参数。具体介绍如下：

此处再次详细说明加载因子(同 JDK 1.7，但由于其重要性，故此处再次说明)

示意图

总结数据结构 & 参数方面与 JDK 1.7的区别

示意图.jpg

5. 源码分析

本次的源码分析主要是根据使用步骤进行相关函数的详细分析
主要分析内容如下：

下面，我将对每个步骤内容的主要方法进行详细分析

步骤1：声明1个 HashMap的对象

此处主要分析的构造函数类似 JDK 1.7

/**
  * 函数使用原型
  */
  Map<String,Integer> map = new HashMap<String,Integer>(); /**
   * 源码分析：主要是HashMap的构造函数 = 4个
   * 仅贴出关于HashMap构造函数的源码
   */public class HashMap<K,V>    extends AbstractMap<K,V>    implements Map<K,V>, Cloneable, Serializable{

    // 省略上节阐述的参数
    
  /**
     * 构造函数1：默认构造函数（无参）
     * 加载因子 & 容量 = 默认 = 0.75、16
     */
    public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR;
    }    /**
     * 构造函数2：指定“容量大小”的构造函数
     * 加载因子 = 默认 = 0.75 、容量 = 指定大小
     */
    public HashMap(int initialCapacity) {        // 实际上是调用指定“容量大小”和“加载因子”的构造函数
        // 只是在传入的加载因子参数 = 默认加载因子
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
        
    }    /**
     * 构造函数3：指定“容量大小”和“加载因子”的构造函数
     * 加载因子 & 容量 = 自己指定
     */
    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);  
        // 设置 加载因子
        this.loadFactor = loadFactor;        // 设置 扩容阈值
        // 注：此处不是真正的阈值，仅仅只是将传入的容量大小转化为：>传入容量大小的最小的2的幂，该阈值后面会重新计算
        // 下面会详细讲解 ->> 分析1
        this.threshold = tableSizeFor(initialCapacity); 

    }    /**
     * 构造函数4：包含“子Map”的构造函数
     * 即 构造出来的HashMap包含传入Map的映射关系
     * 加载因子 & 容量 = 默认
     */

    public HashMap(Map<? extends K, ? extends V> m) {        // 设置容量大小 & 加载因子 = 默认
        this.loadFactor = DEFAULT_LOAD_FACTOR; 

        // 将传入的子Map中的全部元素逐个添加到HashMap中
        putMapEntries(m, false); 
    }
}   /**
     * 分析1：tableSizeFor(initialCapacity)
     * 作用：将传入的容量大小转化为：>传入容量大小的最小的2的幂
     * 与JDK 1.7对比：类似于JDK 1.7 中 inflateTable()里的 roundUpToPowerOf2(toSize)
     */
    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;
}

注：（同JDK 1.7类似）
此处仅用于接收初始容量大小（capacity）、加载因子(Load factor)，但仍无真正初始化哈希表，即初始化存储数组table
此处先给出结论：真正初始化哈希表（初始化存储数组table）是在第1次添加键值对时，即第1次调用put（）时。下面会详细说明
至此，关于HashMap的构造函数讲解完毕。

步骤2：向HashMap添加数据（成对放入键 - 值对）

在该步骤中，与JDK 1.7的差别较大：

示意图.png

添加数据的流程如下

注：为了让大家有个感性的认识，只是简单的画出存储流程，更加详细 & 具体的存储流程会在下面源码分析中给出

示意图.png

源码分析

/**
   * 函数使用原型
   */
   map.put("Android", 1);        map.put("Java", 2);        map.put("iOS", 3);        map.put("数据挖掘", 4);        map.put("产品经理", 5);   /**
     * 源码分析：主要分析HashMap的put函数
     */
    public V put(K key, V value) {        // 1. 对传入数组的键Key计算Hash值 ->>分析1
        // 2. 再调用putVal（）添加数据进去 ->>分析2
        return putVal(hash(key), key, value, false, true);
    }

下面，将详细讲解上面的2个主要分析点

分析1：hash（key）

/**
     * 分析1：hash(key)
     * 作用：计算传入数据的哈希码（哈希值、Hash值）
     * 该函数在JDK 1.7 和 1.8 中的实现不同，但原理一样 = 扰动函数 = 使得根据key生成的哈希码（hash值）分布更加均匀、更具备随机性，避免出现hash值冲突（即指不同key但生成同1个hash值）
     * JDK 1.7 做了9次扰动处理 = 4次位运算 + 5次异或运算
     * JDK 1.8 简化了扰动函数 = 只做了2次扰动 = 1次位运算 + 1次异或运算
     */

      // JDK 1.7实现：将 键key 转换成 哈希码（hash值）操作  = 使用hashCode() + 4次位运算 + 5次异或运算（9次扰动）
      static final int hash(int h) {
        h ^= k.hashCode(); 
        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);
     }      // JDK 1.8实现：将 键key 转换成 哈希码（hash值）操作 = 使用hashCode() + 1次位运算 + 1次异或运算（2次扰动）
      // 1. 取hashCode值： h = key.hashCode() 
      // 2. 高位参与低位的运算：h ^ (h >>> 16)  
      static final int hash(Object key) {           int h;            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);            // a. 当key = null时，hash值 = 0，所以HashMap的key 可为null      
            // 注：对比HashTable，HashTable对key直接hashCode（），若key为null时，会抛出异常，所以HashTable的key不可为null
            // b. 当key ≠ null时，则通过先计算出 key的 hashCode()（记为h），然后 对哈希码进行 扰动处理： 按位 异或（^） 哈希码自身右移16位后的二进制
     }   /**
     * 计算存储位置的函数分析：indexFor(hash, table.length)
     * 注：该函数仅存在于JDK 1.7 ，JDK 1.8中实际上无该函数（直接用1条语句判断写出），但原理相同
     * 为了方便讲解，故提前到此讲解
     */
     static int indexFor(int h, int length) {  
          return h & (length-1); 
          // 将对哈希码扰动处理后的结果 与运算(&) （数组长度-1），最终得到存储在数组table的位置（即数组下标、索引）
          }

总结计算存放在数组 table 中的位置（即数组下标、索引）的过程

此处与 JDK 1.7的区别在于：hash值的求解过程中哈希码的二次处理方式（扰动处理）
步骤1、2 = hash值的求解过程

作者：Sophia_dd35
链接：https://www.jianshu.com/p/8cbd941a89a7

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕标5832272

全栈工程师

手记
篇

粉丝

231

获赞与收藏

1002

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19278 315

Java 并发原理入门教程

26个小节 39003 568

Java 入门教程

50个小节 342046 3165

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Java源码分析：HashMap 1.8 及与HashMap1.7比较

前言

1. 简介

2. 数据结构：引入了 红黑树

2.1 主要介绍

2.2 存储流程

2.3 数组元素 & 链表节点的 实现类

2.4 红黑树节点 实现类

3. 具体使用

3.1 主要使用API（方法、函数）

3.2 使用流程

4. 基础知识：HashMap中的重要参数（变量）

5. 源码分析

步骤1：声明1个 HashMap的对象

步骤2：向HashMap添加数据（成对 放入 键 - 值对）

分析1：hash（key）

阅读免费教程

2. 数据结构：引入了红黑树

2.3 数组元素 & 链表节点的实现类

2.4 红黑树节点实现类

步骤2：向HashMap添加数据（成对放入键 - 值对）