Java中HashMap底层源码分析(JDK1.7)_hashmap put源码分析 jdk1.7-CSDN博客

本文链接：https://blog.csdn.net/Obscurede/article/details/126287852

JDK1.7版本

HashMap源码中的重要常量

分析HashMap首先需要知道HashMap源码里每个常量表示的意义是什么，以及一些常量的值是多少
以下这些变量有个印象即可，一会需要的时候返回这里找就行。
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
MAXIMUM_CAPACITY : HashMap的最大支持容量 2^30
DEFAULT_LOAD_FACTOR:HashMap的默认加载因子
table:存储元素的数组，总是2的n次幂
entrySet:存储具体元素的集
modcdunt: HashMap扩容和结构改变的次数。threshold:扩容的临界值，=容量*填充因子loadFactor:填充因子
填充因子的作用: 在HashMap扩容的时候这个数值会有作用，在HashMap底层计算需要扩容多大的容量的时候，需要填充因子这个常量参与。
size:当前数组存放了多少个键值对

构造器

空参构造器

public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);//调用当前重载的构造器，有一个构造器是专门用于初始化的
        //DEFAULT_INITIAL_CAPACITY:是HashMap这个类里的一个常量，默认值为16，这个常量决定底层开始时创建数组的长度
        //DEFAULT_LOAD_FACTOR:默认的加载因子值为0.75f是一个小数，存在的意义是之后扩容计算要扩容多大的时候需要使用这个填充因子
}

接下来是根据上面的那个默认的空参构造器走下来的，传入的值就是
16和0.75
带参数的构造器，也就是空参构造器里面调用的那个重载的构造器
别慌啊，耐心看，都是人写的，一定能看懂

public HashMap(int initialCapacity, float loadFactor) {
//initialCapacity这个值是一个常量，意义为HashMap的默认容量值为16
//loadFactor是一个常量，是容量不够时扩容需要这个常量
        if (initialCapacity < 0)// 16<0 false
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)//false 16 >1073741824
        //MAXIMUM_CAPACITY是一个常量，HashMap的最大容量值为1073741824
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) //false 0.75<=0 并且FLoat.isNaN(0.75)也是false，因为0.75是一个数Float.isNaN()只有传入的值不是一个数的时候才返回true
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        // Find a power of 2 >= initialCapacity(这句话是源码作者写的)
        
        //到此为止！上面的if条件都不满足，
        
        int capacity = 1;
        while (capacity < initialCapacity)// initialCapacity = 16是传入的值 true，之后就会一直将capacity左移，直到capacity的值最终不满足<16这个条件。
      //{
        //看到这行代码说个小点: 即使你用HashMap进行初始化，传入了一个initialCapacity(这里说的initialCapacity是指这个构造器的参数的这个initialCapacity，不是外面的常量initialCapacity，常量也不能修改的对吧)，你传入的initialCapacity的值如果是单数，以15为例，那么结果最终也不会是15，而是16，因为看下面这行代码你就知道了
        //capacity<<=1;左移1位是*2，capacity的增长是2 - 4 - 8 - 16 始终为2的倍数，所以如果你传入的是15最终计算的结果是16
      //}
            capacity <<= 1;
		
		//从while循环出来我们可以计算出16
        this.loadFactor = loadFactor; //传入的第二个参数loadFactor0.75就给了当前的对象的loadFactor属性
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        //MAXIMUM_CAPACITY在HashMap类里是一个常量，值为1073741824
        //threshold = (int)Math.min(16*0.75,1073741824+1)
        //显然最终的值threshold = 12;
        //threshold这个变量存在的意义是指定什么时候扩容，当底层数组的使用超过这个threshold的时候
        table = new Entry[capacity];
        //table是HashMap底层数组的变量值，在JDK7里数组类型是Entry这个类型
        //根据上面的计算，我们可以看到最终指定capacity的容量为16
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        init();
    }

上面的table数组在HashMap里的样子，

transient Entry<K,V>[] table;//transient涉及到的是序列化的知识

看完构造器的源码后的总结

至此分析源码可得: 在实例化以后，底层创建了长度为16的一位数组table，数组的类型是Entry

Put的源码分析

简介Put方法: 由于HashMap存储的是key，value这样的键值对，Put方法就是将这样的键值对存放到HashMap的数组里

Put的底层源码分析

public V put(K key, V value) {
        if (key == null)//先判断存入的key的值是不是null
            return putForNullKey(value);//如果是null直接存入
        //接下来首先计算key的哈希值
        int hash = hash(key);//跳转到下一个代码块看源码
        //经过这个hash方法之后，我们就得到了一个hash值，这个hash值并不是，最终数组的存放位置
        int i = indexFor(hash, table.length);//跳转到下面看indexFor的源码，返回的这个i就是对应位置的索引
        //for循环的作用:从刚才计算得到的索引i，去取这个索引上的对象，如果索引值为null，则直接添加成功，如果不为null，那么就比较这个位置的哈希值(也是用key计算出来的)和要添加的对象的哈希值是否相同，如果相同，先比较key的地址是否一样(这里相当于最直接的判断，地址一样绝对的就是相同了，这样的效率高)，再用equals判断，毕竟如果两个key的地址都是一样的了那么一定相同，所以先用地址判断，再用equals判断是因为可能存在地址不一样但是key的值可能相同的情况
        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))) {
            //如果key值相同，则用新添加的对象的value替换掉旧的value
            
                V oldValue = e.value;//把已经添加的数据作为oldValue
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        //添加成功时调用addEntry方法
        addEntry(hash, key, value, i);
        return null;
    }

hash这个方法的源码

//位运算符在集合的底层源码中有着大量的使用，因为位运算的效率相对较高
//hash这个方法里的代码不用细看，你可以理解为整体经过一系列计算算出了一个Hash值，这个值里面调用了HashMap的key所在类的HashCode方法
//其实从侧面也说明了为啥HashMap里的key的类必须要重写HashCode方法，因为底层要调用
final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

indexFor的源码
利用传入进来的哈希值，和数组本身的长度来进行&与运算，运算的结果一定不会超过16
在这里插入图片描述

length的长度为

static int indexFor(int h, int length) {
        return h & (length-1);
    }

最终返回的值一定是0到lenght-1，所以，这个值可以作为数组的索引

addEntry底层源码

   void addEntry(int hash, K key, V value, int bucketIndex) {
   //原作者对size这个变量的解释: 
   //The number of key-value mappings contained in this map.(键值对在当前的map里的个数)
       if ((size >= threshold) && (null != table[bucketIndex])) {
       //threshold是之前利用填充因子loadFactor和当前数组的大小计算出来的
       //是一个边界值，用于判断是否需要扩容
       //这里添加一个Entry时就要考虑扩容，当Size(当前数组的大小>边界值的时候并且插入数据的位置不为空才考虑扩容，因为为空的话，那么就直接放这儿得了)
       
           resize(2 * table.length);
           hash = (null != key) ? hash(key) : 0;//重新计算原有的哈希值
           bucketIndex = indexFor(hash, table.length);//重新计算它们在新的数组里放的位置
       }

       createEntry(hash, key, value, bucketIndex);
   }

createEntry和Entry的底层源码可以分析得，当新添加进来一个数据的时候，这个数据会站着原来这个数据在数组的位置，然后将其他的数据以链表的形式链在这个新数据的身后

createEntry的源码

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

Entry的底层源码

Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

看完Put源码后的总结

看过Put方法可以知道JDK7里，key可以添加null，添加的过程是先利用key值计算一个Hash值，根据这个Hash值和当前数组的大小，去计算新添加的对象应该添加在哪个位置，然后去找这个位置上有没有Entry对象
如果有:
和这个位置上的对象逐个比较key值
若相等: 用新对象的value替换掉旧对象的value，只要有一个相等则结束比较。
若都比较完了，都没有相等的，说明这个对象的key是独一无二的，则添加成功。
若没有:
直接添加成功
简述添加成功的过程: 先判断是否需要扩容，需要扩容的话就扩容，然后再将传入的哈希值，key值，value值，以及原来这个位置上的对象，封装到一个新的Entry中，然后新的Entry占在旧的Entry数组的位置，然后旧的Entry以链表的形式链在新的Entry上

在这里插入图片描述
Thanks For Watching!!!💕