美文网首页
源码之HashMap构造函数底层分析

源码之HashMap构造函数底层分析

作者: czczccz | 来源:发表于2021-03-04 20:20 被阅读0次

    基于 1.8

    HashMap在JDK1.8之前是由数组加链表组成的,其中数组是主体,链表则是为了解决哈希冲突存在的。

    1.8之后HashMap的组成多了红黑树,当链表的长度超过8的时候,就会把链表转换成红黑树。加快了索引速度。

    00 :构造函数

    还从构造函数先看起,HashMap总共提供给我们了四个构造函数,分别为:

    public HashMap(int initialCapacity, float loadFactor) {...}
    public HashMap(int initialCapacity) {...}
    public HashMap() {...}
    public HashMap(Map<? extends K, ? extends V> m) {
    

    先看无参构造

    • 无参构造

           /**
           * 当构造函数没有指定加载因子的大小时候,使用0.75
           */
          static final float DEFAULT_LOAD_FACTOR = 0.75f;
        /**
           * HashTable的加载因子
           * @serial
           */
          final float loadFactor;
        /**
           * 使用默认的容量大小、初始的加载因子,构造一个空的HashMap。
            初始容量为16,初始的加载因子为0.75
           */
          public HashMap() {
              this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
          }
      

      无参构造就设置了下HashMap的加载因子为 0.75,其他啥也没干,加载因子后面会用来扩容使用,这里先不提。

      而且从这里我们还看不出来,保存HashMap数据的使用的是哪个数据结构。

    • 含参构造 - int

      /**
        根据指定的容量以及默认的0.75的加载因子构造一个空的HashMap
      */
      public HashMap(int initialCapacity) {
          this(initialCapacity, DEFAULT_LOAD_FACTOR);
      }
      

      小老板不谈了,这里直接调用了另一个构造方法。

    • 含参构造 - int , float

          /**
           * 最大容量
          */
          static final int MAXIMUM_CAPACITY = 1 << 30;
          /**
           阈值 当实际大小(容量*填充因子)超过阈值时,会进行扩容
          **/
          int threshold;
        /**
           * 根据指定的容量大小和加载因子,构造一个空的HashMap
           */
          public HashMap(int initialCapacity, float loadFactor) {
              if (initialCapacity < 0) //初始容量不能为0
                  throw new IllegalArgumentException("Illegal initial capacity: " +
                                                     initialCapacity);
              if (initialCapacity > MAXIMUM_CAPACITY) //超过最大值,设为最大值
                  initialCapacity = MAXIMUM_CAPACITY;
              if (loadFactor <= 0 || Float.isNaN(loadFactor)) //判断加载因子是否合法,isNan是用来判断是不是非数
                  throw new IllegalArgumentException("Illegal load factor: " +
                                                     loadFactor);
              this.loadFactor = loadFactor; //将加载因子设置成指定的值
              this.threshold = tableSizeFor(initialCapacity);//根据设置的容量大小计算出阈值,阈值计算方式如下函数
          }
        
        
          /**
           >>>表示无符号右移,也叫逻辑右移,即若该数为正,则高位补0,比如7的二进制是111,7>>>2表示右移2位,变成001,即为1
           查所传的参数是否为2的幂次方,且不能为负数(负数变为1),且不能超过常量MAXIMUM_CAPACITY(超过变为MAXIMUM_CAPACITY),如果不为2的幂次方,将其变为,比cap大的最小的2的幂次方的值;
           */
          static final int tableSizeFor(int cap) {
              int n = cap - 1;
              n |= n >>> 1;//现将n无符号右移1位,并将结果与右移前的n做按位或操作,结果赋给n
              n |= n >>> 2;
              n |= n >>> 4;
              n |= n >>> 8;
              n |= n >>> 16;
              //中间过程的目的就是使n的二进制数的低位全部变为1,比如10,11变为11; 100,101,110,111变为111;
              return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
          }
      

      这个构造函数都干了什么呢?传入数据正确性的判断我们就不讨论了,后面首先重新设置加载因子,然后根据用户传入的容量大小,设置阈值的大小,阈值设置为与容量大小距离最近且为2的幂次方的数。

    • 含参构造 - Map

          public HashMap(Map<? extends K, ? extends V> m) {
              this.loadFactor = DEFAULT_LOAD_FACTOR;//设置加载因子为 0.75
              putMapEntries(m, false);//看下面的解析
          }
      
      //存放元素的数组
      transient Node<K,V>[] table;
      
      //实现Map.putAll以及构造函数的功能,m为传入的要转换成HashMap的map,evict设置为false表示是构造时候使用,反之不是    
      final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
              int s = m.size();//m的大小
              if (s > 0) {
                  if (table == null) { // table是不是初始化过
                      //将s除以负载因子+1可以得到HashMap所需的最大阈值
                      float ft = ((float)s / loadFactor) + 1.0F;
                      //如果计算得到的最大阈值大于最大值,则将t赋值为最大值
                      int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                               (int)ft : MAXIMUM_CAPACITY);
                      //如果t大于当前的临界值,重新根据t计算临界值
                      if (t > threshold)
                          threshold = tableSizeFor(t);
                  }
                  //已经初始化过,并且s内的个数已经大于了阈值,进行扩容
                  else if (s > threshold)
                      resize();
                  //将m中的所有元素都添加到Hashmap中
                  for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                      K key = e.getKey();
                      V value = e.getValue();
                      putVal(hash(key), key, value, false, evict);
                 }
              }
          }
      

    构造函数我们看完了,主要就是容量、加载因子、临界值的设定。那到底是谁存储的的元素,谁设置的默认容量呢,如下是其他相关的变量定义。

        /**
         * The default initial capacity - MUST be a power of two.
         */
        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
        //存放元素的数组
        transient Node<K,V>[] table;
        //存放具体元素
        transient Set<Map.Entry<K,V>> entrySet;
    

    构造函数中还出现了重要的方法resize,我们到扩容的时候再解析。

    相关文章

      网友评论

          本文标题:源码之HashMap构造函数底层分析

          本文链接:https://www.haomeiwen.com/subject/ltzkqltx.html