HashMap源码分析

Posted 2020-09-19 Yrion

本篇博文的目录：

一：HashMap简介

二：HashMap的结构

三：HashMap的源码分析

3.1： 成员变量

3.2:  构造函数

3.3：内部类

3.4：put方法

3.5：get方法

3.4:  其余方法

四：HashMap的最重要的几个问题

五：总结

 

前言：HashMap作为在Java中的高频率使用的一个数据存储容器，其属于key、value非常流行的方式，我们几乎每天都要使用Hashmap用来存放数据，比如FreeMarker、mybatis中，都是通过HashMap包装数据，然后把数据传给框架去解析后找到具体的数据，可以说使用率相当广泛。同时，它也是我们面试中的基本属于必考的问题，记得小Y我在刚不久前的面试中，大约面试了7、8家，可谓关于HashMap的是属于非常容易出现的问题，所以说学好HashMap不仅对我们深入理解Java数据结构有益。更对我们求职找工作也是不可获取的一部分，本期博客，我们就来聚焦HashMap，挖一下HashMap的底层原理，看它究竟是如何工作的。说明：本次源码分析基于jdk1.6，如果你看到的版本和我的不一致，很可能是jdk版本不一样

 

一：HashMap简介

   HashMap是属于键值形式的，这点上不同于list和数组的形式，像list这种结构的数据。它只能记录单一数据，无法对数据进行说明。而数组，它适合用来记录一序列类型相同数据，有很大的局限性。而HashMap这种方式非常合理并且在计算机系统中是高频出现的，举个栗子，比如我们要记录一个文件的属性，比如文件的大小、文件格式、文件类型等等，那么就可以采用HashMap来存储，map.put("FileSize","1024MB"),map.put("isRead",true)等等，可谓是一把记录数据的利器。同时，它继承于AbstractMap、实现了Map接口和cloneable、Serializable接口，这就说明了它具备一定的克隆能力和可序列化能力（详情参考以下代码：public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable），可序列化的话，那么它就可以写入磁盘里，这样实现了数据的持久化。

二：HashMap的结构

  HashMap属于一个类，维护有成员变量，它是采用数组+链表的形式来容纳数据的，因此在它的类中维护着一个静态内部类，名字叫做Entry,这就是其维护的数组，那么它的链表是什么呢？链表指的是在数组的节点上，有一个next指针，指针指向下一个Entry，这就在其节点上形成了一个链表，这么说可能有点抽象，我们来画一张图来直观的感受一下：如果在其节点上，衍生出来的具有指针的就是其链表结构

 

三：HashMap的源码分析

3.1：成员变量

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

   
    static final int DEFAULT_INITIAL_CAPACITY = 16; //默认的初始容量（必须是2的次方）

   
    static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量值。 2的30次方

   
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认的加载因子（如果你构造方法中没有传入的话，会用这个）

  
    transient Entry[] table;//维护的数组（长度必须为2的次方）

    
    transient int size;//大小（用transient表示该字段无法被序列化）

    
    
    int threshold;//因为它表示的是resize也就是扩容的指标，我们暂且把它称为扩容临界值

  
    final float loadFactor;//加载因子

   
    transient volatile int modCount;//修改表的次数，比如你put一次这个值就会+1

 从维护的成员变量中，我们可以发现它有自己的容量大小、还有数组、大小、加载因子等。这些东西具体是干嘛的我们会接着往下讲，大家先知道有这么一个概念，我们继续往下看。

3.2：HashMap的构造函数

   public HashMap(int initialCapacity, float loadFactor) {//HashMap的构造函数 初始容量 加载因子
        if (initialCapacity < 0)                          //初始容量如果小于0
            throw new IllegalArgumentException("Illegal initial capacity: " +//抛出异常
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)//默认初始容量大于最大容量
            initialCapacity = MAXIMUM_CAPACITY;//
        if (loadFactor <= 0 || Float.isNaN(loadFactor))//加载因子小于0 或者不是一个数字
            throw new IllegalArgumentException("Illegal load factor: " +//抛出异常
                                               loadFactor);

        
        int capacity = 1;//容量=1
        while (capacity < initialCapacity)//小于初始容量
            capacity <<= 1;//左移1位，相当于乘以2

        this.loadFactor = loadFactor;//传递加载因子
        threshold = (int)(capacity * loadFactor);//容量*加载因子
        table = new Entry[capacity];//初始化数组
        init();//调用初始化方法
    }

  
    public HashMap(int initialCapacity) {//构造函数 定义初始化容量
        this(initialCapacity, DEFAULT_LOAD_FACTOR);//调用构造函数，把默认的加载因子传播进去
    }

    
    
    public HashMap() {   //无参的构造函数
        this.loadFactor = DEFAULT_LOAD_FACTOR;//默认的加载因子
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);//扩容临界值=默认的初始容量*默认的加载因子
        table = new Entry[DEFAULT_INITIAL_CAPACITY];//初始化数组,用默认的初始化容量
        init();//初始化
    }

    
    public HashMap(Map<? extends K, ? extends V> m) { //  构造一个映射关系与指定Map相同的新 HashMap
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        putAllForCreate(m);
    }

    void init() {//初始化
    }

从上面可以看出HashMap具有四个构造函数，我们依次看一下：

第一个构造函数：使用自定义的初始容量、和加载因子，首先对初始容量进行校验不能小于0（否则会抛异常），然后其不能大于最大容量值（否则还是用最大容量值），再校验加载因子不能小于0,还必须是数字。再初始化加载因子和上面的成员变量数组、扩容临界值为容量*加载因子。但是一般这个构造函数我们用的不是很多，一般都会选择使用无参的构造函数。

第一个构造函数：只有一个初始容量的参数，会默认调用第一个构造函数，把加载因子设为默认的加载因子。

第三个构造函数：也就是无参构造函数，默认会初始化加载因子（0.75）,初始化扩容临界值，初始化数组

第四个构造函数：这个构造函数用的很少，主要是构造一个映射关系与指定Map相同的新 HashMap

3.3：内部数组类

  static class Entry<K,V> implements Map.Entry<K,V> {//内部类 -数组
        final K key; //键值
        V value;//值
        Entry<K,V> next;//下一个值
        final 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;
        }

　　可以看到HashMap内部维护的数组是有key、value属性，同时其拥有一个指针，指向下一个Entry，默认的构造函数构造的时候会把所有的成员变量构造进去。这是就是为什么说HashMap是数组+链表的结构的原因。

3.4：put方法

在看put方法之前，我们先来看一下两个很重要的方法：

  static int hash(int h) {//通过传入的hashcode来计算hash值
        
        h ^= (h >>> 20) ^ (h >>> 12);//异或运算，右移12位和右移20位计算hash值
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    
    static int indexFor(int h, int length) {//通过hashcode找在哈希表中的位置，返回具体的位置
        return h & (length-1);//采用的是异或运算等价于 hash%(table.length) length是2的次方数
    }//正好获取了数组的位置

　　这两个方法，hash()方法主要是进行计算传入的hashcode的哈希值，而indexFor主要是用过hash值和数组的长度来返回一个int型的数字，这个方法主要是寻找在一个数组中插入的位置。

好了，接下来我们看具体的put()方法：

 public V put(K key, V value) {  //放入的方法（键和值）
        if (key == null)//如果键为null的情况
            return putForNullKey(value);//返回处理键为null的方法
        int hash = hash(key.hashCode());//通过键的hashcode生成一个唯一hash值
        int i = indexFor(hash, table.length);//根据哈希值在数组中找位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {//从位置处开始遍历循环链表，如果e不为null。证明该位置已经有元素了
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {//比较hash值和键相等，如果key相同
                V oldValue = e.value;//把数组中的值存储起来
                e.value = value;//用值替换旧值
                e.recordAccess(this);//记录处理
                return oldValue;//返回旧值
            }
        }

        modCount++;//修改次数+1
        addEntry(hash, key, value, i);
        return null;
    }

　　看put方法，传入的是key和value两个值，首先呢，判断键如果为null的情况下，会有一个处理null的方法，这也就直接说明了HashMap是允许键为null的。如果不为null，通过键的hashcode传入Hash方法，计算hash值，再把其hash值传入indexFor方法，找其在数组中的位置，也就是要把值放入的位置，然后开始在数组中遍历，假设我们是第一个存入的值，那么它此时Entry为null，就不会走for循环，我们继续放下走，给修改次数+1，调用addEntry方法：

 void addEntry(int hash, K key, V value, int bucketIndex) { //添加entry对象
	Entry<K,V> e = table[bucketIndex];  
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);//新建一个entry
        if (size++ >= threshold)//如果size>扩容临界值
            resize(2 * table.length);  //数组的原有长度扩大两倍
    }

　　这个方法主要是用来给指定的数组位置添加entry对象的，我们看一下它会new一个Entry对象，然后在计算出来的位置进行构造生成对象，放入我们传入的key和value的值。同时，这里进行了对数组长度的判断，如果大于扩容临界值，就会对其进行resize,也及时扩容操作，扩容是数组长度的2倍。

以上讲解的是初次进入数组的情况，那么假如我们计算出来的位置上，已经有元素存在，怎么办？

我们来继续看代码，在我们计算出位置以后，此时位置上有元素，这就说明了e！=null，那么就会进入for循环，然后进行对数组上的链表进行遍历（注意此时是链表），如果找到key相同的entry元素，那么就会对其value值进行覆盖，如果没有找到，也就是说链表上此时没有相同的key，那么就会走addentry方法，在计算出来的位置上，在链表的首部创建一个新的Entry对象，此时就把键和值放入进去了。

3.5:get方法

  public V get(Object key) {//get方法，通过键获取值
        if (key == null)    //如果键为null的情况下
            return getForNullKey();//处理键为null的情况
        int hash = hash(key.hashCode());//通过键的hashcode计算哈希
        for (Entry<K,V> e = table[indexFor(hash, table.length)];//找到数组中存放的位置
             e != null;
             e = e.next) {//遍历循环
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))//比较数组中的数的哈希键和传入的键的哈希值，只有其hash值相同、并且键相同（通过==和equals确保）
                return e.value;//返回数组中的数对应的值
        }
        return null;//如果找不到就返回null
    }

　　我们来看get方法，get方法首先会传入一个键值，判断其是否非空，然后计算hash值，然后再回链表进行遍历，如果找到和传入的key相同的元素，直接取其value值返回，如果找不到就返回null。get方法比较简单，就是一个遍历寻找值的过程，这里也很好理解，需要注意的就是其还有进行比对Hash值

3.6：其他方法

我们先来看一下其扩容方法：

  void resize(int newCapacity) {  //扩容方法
        Entry[] oldTable = table;//旧的数组表
        int oldCapacity = oldTable.length; //取旧数组的长度
        if (oldCapacity == MAXIMUM_CAPACITY) {//最大的容量
            threshold = Integer.MAX_VALUE;//扩容临界值=最大int值
            return;
        }

        Entry[] newTable = new Entry[newCapacity];//创建新的数组
        transfer(newTable);//转移数据
        table = newTable;//新数组
        threshold = (int)(newCapacity * loadFactor);//
    }

　　

  void transfer(Entry[] newTable) { //转移到新的数组中
        Entry[] src = table;
        int newCapacity = newTable.length;//新数组的长度
        for (int j = 0; j < src.length; j++) {//遍历
            Entry<K,V> e = src[j]; //Entry
            if (e != null) {//e!=null
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;//指向新的个entry点
                    int i = indexFor(e.hash, newCapacity);//寻找数组中的位置
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

　　扩容方法，首先还是虚拟一个旧数组。然后新建一个新的数组，主要是为了存放数据，再通过transfer方法，进行遍历循环，把数组挨个复制到新的数组里面，一定要注意的此时的新数组的长度是旧数组的2倍。

再来看看我们常用的几个方法：

    public int size() {//计算HashMap大小的方法
        return size;//返回size的值
    }

  
    public boolean isEmpty() {//判断map是不是空
        return size == 0;//用0和size的值做比较，是0返回true，否则返回false
    }

　　size()方法，直接返回size成员变量的大小，isEmpty（）判断map是不是空的，直接比较0和size的大小，很简单。这里一看代码才恍然大悟，原来是这么做的，所以我们要养成经常多看源码的习惯。

 四：HashMap几个重要的问题（面试中经常遇到的）

1: HashMap是如何put的？

答：是通过key的hashcode方法再计算hash值，然后再计算存放在数组中的位置，构建一个Entry对象，把key、value值包装进去，存入在数组中。

2：如果在放入值的时候，已经有键存在了，怎么办？

答：它会比较key的hash值和内存地址、内容，如果相同，就会用新值替换原来的旧值

3：HashMap如果在存放值的时候产生了Hash冲突怎么办？

答：Hash冲突指的是，计算出来的位置在同一处，那么它就会遍历该处的链表，如果有相同的key，它就会覆盖原来的旧值，如果没有它会在链表中创建一个entry对象，把具体的key、value封装进去，添加到链表的首部

4：HashMap允许键为空吗？存放的键为空怎么办？

答：允许，如果键为空，它会在数组的第一个位置上创建entry元素，以null作为key，值作为键放入到数组中

5；我们都知道数组是有长度限制的，如果数组的长度超过限制怎么办？

数组的长度超过了限制，HashMap会调用resize()方法，对其进行扩容，扩容的临界值是数组容量*加载因子，如果按照默认的，那么默认容量是16，加载因子是0.75，也就是要16*0.75=12,数组中的容量超过12就会进行扩容，扩容的长度是原来的2倍，也就是16*2=32

7：在看了HashMap源码后，你应该注意什么？

注意第一点：减少哈希冲突，因为一旦放入链表中，以后总是要遍历链表，效率差。要尽量把元素直接放入数组中，而非链表，根据实际情况，重写hashCode和equals方法。

注意第二点：HashMap底层是数组，尽量减少扩容，所以HashMap放入元素的时候，应该估算数组的大小，避免扩容操作

注意第三点：尽量不要修改默认的加载因子0.75，这个数字是经过科学计算来的

8：HashMap是线程安全的吗？如果要它变成线程安全的，应该怎么做？

答：HashMap是非线程安全的，也并不是同步的。如果要线程安全，可以使用concurrenthashmap这个类，也可以用Collections.syzchronizedMap(HashMap map),进行构造会返回一个新的HashMap此时的hashMap就是线程安全的。

五：总结

本篇博文对HashMap进行了一个讲解，主要是放在了其put方法和get方法上的讲解上，同时回答了一些常见的hashMap的问题，希望大家有一定的收获。学习hashMap对我们的java学习来说非常重要，如有问题，大家可以留言，我们一起探讨，本篇博文就介绍到这里，如有错误，还望指出，谢谢。