JDK 7 HashMap源码解读

最新推荐文章于 2022-05-01 10:58:10 发布

用针戳左手中指指头

最新推荐文章于 2022-05-01 10:58:10 发布

阅读量225

点赞数

分类专栏：多线程文章标签：数据结构 hashmap java 链表

本文链接：https://blog.csdn.net/qq_28911061/article/details/107148550

版权

多线程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

文章目录

原理说明
源码解析

原理说明

数组是最基本的数据结构，ArrayList内部就是数组实现的，下标定位位置，然后在数组下标位置存放元素，每添加一个元素，下标就+1，map和list有一点相似，就是内部也有个数组，它通过key存放获取对象，以key计算数组下标。使用hashCode的话，得出的值很大，很容易是数组越界，可以使用取余的方式减小这个，那么余多少呢？比如下标是0-7，那么我们可以余它的数组大小（length），hashCode是随机的，得出的下标也是随机的，这也使得数组下标随机平均。

但还有一个问题，hashCode是随机的，但在取余之后得到的值很可能是相同的，比如第一次你存了kk1: vv1，第二次存放kk2: vv2计算key后得出的位置也是同一个位置，那么在同一下标有两个对象了，那么可以链表去解决这个问题；再来一个，也是计算得到同一个下标，考虑一个问题，是插入头部比较快还是尾部比较快？
如果是头插法，只需要修改新节点的next的下一个节点指针就行了，而如果是尾插，那么还需要遍历链表，然后修改尾部的指针，显然，尾插法的效率不是很高，map里就是用的头插法，头插法只有next的元素，这是查找下一个元素使用的，它没有向上查找的方式，它的查找方式也是先计算数组下标，得到下标后，找到对应的链表，然后遍历的：
在这里插入图片描述

上面只是对map的一个原理说明，并不严谨。

源码解析

这里从HashMap的源码上去看HashMap这个结构，从源码分析理解。

它的结构是：

entry数组，entry是链表；

静态常量

HashMap里有这些个属性：

	// 默认初始容量 16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
	// 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
	// 默认加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
	// 空数组对象
    static final Entry<?,?>[] EMPTY_TABLE = {};
	// 内部数组，
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
	// map长度
    transient int size;
	// 阈值，是否扩容根据这个判断：threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1) => capacity * loadFactor
    int threshold;
	// 加载因子，扩容计算用到
    final float loadFactor;
	// 修改计数
    transient int modCount;
	// hash种子，计算hash值用到，为了是计算的hashCode更加的散列随机。
	transient int hashSeed = 0;

构造函数

看的构造方法，这里传进了两个值，这两个值都是默认给定的，在上面的变量中可以找到，分别是16和0.75f

public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, 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;
      // 阈值
        threshold = initialCapacity;
      // 这个init没什么作用
        init();
    }

构造方法中是做了简单初始化（对默认值进行设置），但并未对内部的结构初始化，所以，它new的时候，并不进行任何的操作，只有当它使用时才会进行进一步的初始化（对内部数组初始化）；

put操作

接着看put方法（添加操作）：

public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
    // key == null 的情况
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

初始化数组

put方法一进来就是这个，初始化内部数组，这里的threshold是在构造方法中初始化的一个默认值，这个值是16。

 if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }

进入inflateTable方法，这个方法它有3个操作，首先是一个计算容量的方法roundUpToPowerOf2，然后计算阈值threshold，然后是计算哈希种子。

 private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        int capacity = roundUpToPowerOf2(toSize);

        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

这里通过roundUpToPowerOf2方法产生一个初始化的数组大小，跟进roundUpToPowerOf2方法，看看它是怎么生成的：

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

首先是判断number（阈值）是否是大于等于最大容量值，
number肯定是小于等于的
所以是走这个代码：(number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1

上面这一串就重点看：

 Integer.highestOneBit((number - 1) << 1)

默认的初始化，number就是16

 public static int highestOneBit(int i) {
        // HD, Figure 3-1
        i |= (i >>  1);
        i |= (i >>  2);
        i |= (i >>  4);
        i |= (i >>  8);
        i |= (i >> 16);
        return i - (i >>> 1);
    }

这个是计算小于等于当前值的二次方数，比如下面给定值为17，其结果是16，给定值是18,19,20都会是16，

i=17 =>
0000 0000 0000 0000 0000 0000 0001 0001

(i >> 1) =>
0000 0000 0000 0000 0000 0000 0000 1000

i |= (i >> 1) =>
0000 0000 0000 0000 0000 0000 0001 1000
…

i |= (i >> 16) =>
0000 0000 0000 0000 0000 0000 0001 1111

i - (i >>> 1) =>
0000 0000 0000 0000 0000 0000 0001 1111
0000 0000 0000 0000 0000 0000 0000 1111
0000 0000 0000 0000 0000 0000 0001 0000

了解了highestOneBit方法后，再看上一层代码，为什么要-1，和左移1位？

 Integer.highestOneBit((number - 1) << 1)

原因是为了得到小于等于指定值的最大2次方数

我们要得到的是一个大于等于在给定值的一个2的幂次方数，highestOneBit得到的是一个小于等于给定值的幂次方数，所以左移1位；假如我们给定值为17，那么要得到的结果应该是32，如果我们不左移，最后得到的值就会是16
假如给定值是16，要得到结果应该是16，左移1位得到32，所以左移前-1得到15，在左移得到30才能得到16

roundUpToPowerOf2注释写着要2的每次方数，那为什么要2的幂次方数呢（为什么map的长度需要2的幂次方）？

可以看看这篇博客，比较详细： https://blog.csdn.net/LLF_1241352445/article/details/81321991?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase

其结论就是：为了能够是hash计算出的key，能够更加平均的分散在数组的各个索引下。

添加对象

接着put方法；

  if (key == null)
            return putForNullKey(value);

 private V putForNullKey(V value) {
     // 遍历内部数组的第0个位置的链表，查找是否有key == null的键，如果有就返回旧值
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                // 这个方法不管他，跟hashMap没有关系，这个是给它子类（LinkedHashMap）写的。
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

key==null的话，那么它对应的hash值就是0，对应的索引也是0；

  void addEntry(int hash, K key, V value, int bucketIndex) {
        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);
    }

再回到put方法：

public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            // 初始化数组
            inflateTable(threshold);
        }
    // 第一种情况key == null
        if (key == null)
            return putForNullKey(value);
    // 计算hash值
        int hash = hash(key);
    // 这里就是hash & (table.length - 1)
    // 计算数组下标
        int i = indexFor(hash, table.length);
    // 遍历数组下标对应的链表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 判断key计算的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;
            }
        }
		// 每次修改+1
        modCount++;
    // 如果没有找的对应的，就新增一个
        addEntry(hash, key, value, i);
        return null;
    }

上面这个modCount这个标识是一种快速失败的机制，多线程下，一个线程在遍历，一个线程在新增或删除，遍历到了第3个，而删除了第二个，而这时已经遍历了3个了，但是第二个被删除了，总数不对，如果取值，也取不到，所以每次修改都会记录，在遍历时会去判断，不一样会报错。

下面是添加一个entry

  void addEntry(int hash, K key, V value, int bucketIndex) {
      // 判断数组大小是否大于等于阈值 且要添加的位置有元素
        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++;
    }

这里是直接获取到数组下标的元素，然后new Entry，这个构造方法中是将e（原数组下标的对象，也就是数组下标对应的链表entry）给了新entry的next（指针），这也就是我们开篇是说的头插法。

扩容

扩容就是扩大数组容量大小，那么就会有重新计算它的各个值，如阈值、容量；当存储数量大于等于阈值时，就会触发扩容，过程就是重新创建一个数组，然后再把元素转移。

看看数组元素转移的方法，这个也比较简单的，就是重新计算下标

 void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
     // 遍历就数组
        for (Entry<K,V> e : table) {
            // 遍历每一个元素下的链表
            while(null != e) {
                Entry<K,V> next = e.next;
                // 重新计算hash值
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                // 计算数组下标
                int i = indexFor(e.hash, newCapacity);
                // 转移到新数组
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

get操作

而get方法相对简单些:

第一种是获取key = null的value

 public V get(Object key) {
        if (key == null)
            // key == null 的情况
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        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) {
            // 找到key == null 的元素并返回
            if (e.key == null)
                return e.value;
        }
        return null;
    }

第二种是获取key ！= null的value；

这种方式通过key计算出hash值，然后在计算数组下标，拿到对应的entry，然后遍历entry，通过判断hash值和equals来判断是否我们要的对象。

final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }
		// 计算位置
        int hash = (key == null) ? 0 : hash(key);
        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;
    }