集合框架源码学习之HashMap(JDK1.8)

目录:

0-1. 简介
0-2. 内部结构分析
  0-2-1. JDK18之前
  0-2-2. JDK18之后
0-3. LinkedList源码分析
  0-3-1. 构造方法
  0-3-2. put方法
  0-3-3. get方法
  0-3-4. resize方法
0-4. HashMap常用方法测试

简介

HashMap主要用来存放键值对,它基于哈希表的Map接口实现,是常用的Java集合之一。与HashTable主要区别为不支持同步和允许null作为key和value,所以如果你想要保证线程安全,可以使用ConcurrentHashMap代替而不是线程安全的HashTable,因为HashTable基本已经被淘汰。

内部结构分析

JDK1.8之前:

JDK1.8之前HashMap底层是数组和链表结合在一起使用也就是链表散列。HashMap通过key的hashCode来计算hash值,当hashCode相同时,通过“拉链法”解决冲突。
所谓“拉链法”就是:将链表和数组相结合。也就是说创建一个链表数组,数组中每一格就是一个链表。若遇到哈希冲突,则将冲突的值加到链表中即可。集合框架源码学习之HashMap(JDK1.8)
简单来说,JDK1.8之前HashMap由数组+链表组成的,数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的,如果定位到的数组位置不含链表(当前entry的next指向null),那么对于查找,添加等操作很快,仅需一次寻址即可;如果定位到的数组包含链表,对于添加操作,其时间复杂度依然为O(1),因为最新的Entry会插入链表头部,急需要简单改变引用链即可,而对于查找操作来讲,此时就需要遍历链表,然后通过key对象的equals方法逐一比对查找.

JDK1.8之后:

相比于之前的版本,jdk1.8在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为8)时,将链表转化为红黑树,以减少搜索时间。集合框架源码学习之HashMap(JDK1.8)
类的属性:
  1. publicclassHashMap<K,V>extendsAbstractMap<K,V>implementsMap<K,V>,Cloneable,Serializable{
  2.    // 序列号
  3.    privatestaticfinallong serialVersionUID =362498820763181265L;    
  4.    // 默认的初始容量是16
  5.    staticfinalint DEFAULT_INITIAL_CAPACITY =1<<4;  
  6.    // 最大容量
  7.    staticfinalint MAXIMUM_CAPACITY =1<<30;
  8.    // 默认的填充因子
  9.    staticfinalfloat DEFAULT_LOAD_FACTOR =0.75f;
  10.    // 当桶(bucket)上的结点数大于这个值时会转成红黑树
  11.    staticfinalint TREEIFY_THRESHOLD =8;
  12.    // 当桶(bucket)上的结点数小于这个值时树转链表
  13.    staticfinalint UNTREEIFY_THRESHOLD =6;
  14.    // 桶中结构转化为红黑树对应的table的最小大小
  15.    staticfinalint MIN_TREEIFY_CAPACITY =64;
  16.    // 存储元素的数组,总是2的幂次倍
  17.    transientNode<k,v>[] table;
  18.    // 存放具体元素的集
  19.    transientSet<map.entry<k,v>> entrySet;
  20.    // 存放元素的个数,注意这个不等于数组的长度。
  21.    transientint size;
  22.    // 每次扩容和更改map结构的计数器
  23.    transientint modCount;  
  24.    // 临界值 当实际大小(容量*填充因子)超过临界值时,会进行扩容
  25.    int threshold;
  26.    // 填充因子
  27.    finalfloat loadFactor;
  28. }
(1)loadFactor加载因子
loadFactor加载因子是控制数组存放数据的疏密程度,loadFactor越趋近于1,那么 数组中存放的数据(entry)也就越多,也就越密,也就是会让链表的长度增加,load Factor越小,也就是趋近于0,
loadFactor太大导致查找元素效率低,太小导致数组的利用率低,存放的数据会很分散。loadFactor的默认值为0.75f是官方给出的一个比较好的临界值。  
(2)threshold
threshold = capacity * loadFactor当Size>=threshold的时候,那么就要考虑对数组的扩增了,也就是说,这个的意思就是 衡量数组是否需要扩增的一个标准
Node节点类源码:
  1. // 继承自 Map.Entry<K,V>
  2. staticclassNode<K,V>implementsMap.Entry<K,V>{
  3.       finalint hash;// 哈希值,存放元素到hashmap中时用来与其他元素hash值比较
  4.       final K key;//键
  5.       V value;//值
  6.       // 指向下一个节点
  7.       Node<K,V> next;
  8.       Node(int hash, K key, V value,Node<K,V> next){
  9.            this.hash = hash;
  10.            this.key = key;
  11.            this.value = value;
  12.            this.next = next;
  13.        }
  14.        publicfinal K getKey()        {return key;}
  15.        publicfinal V getValue()      {return value;}
  16.        publicfinalString toString(){return key +"="+ value;}
  17.        // 重写hashCode()方法
  18.        publicfinalint hashCode(){
  19.            returnObjects.hashCode(key)^Objects.hashCode(value);
  20.        }
  21.        publicfinal V setValue(V newValue){
  22.            V oldValue = value;
  23.            value = newValue;
  24.            return oldValue;
  25.        }
  26.        // 重写 equals() 方法
  27.        publicfinalboolean equals(Object o){
  28.            if(o ==this)
  29.                returntrue;
  30.            if(o instanceofMap.Entry){
  31.                Map.Entry<?,?> e =(Map.Entry<?,?>)o;
  32.                if(Objects.equals(key, e.getKey())&&
  33.                    Objects.equals(value, e.getValue()))
  34.                    returntrue;
  35.            }
  36.            returnfalse;
  37.        }
  38. }
树节点类源码:
  1. staticfinalclassTreeNode<K,V>extendsLinkedHashMap.Entry<K,V>{
  2.        TreeNode<K,V> parent;  // 父
  3.        TreeNode<K,V> left;    // 左
  4.        TreeNode<K,V> right;   // 右
  5.        TreeNode<K,V> prev;    // needed to unlink next upon deletion
  6.        boolean red;           // 判断颜色
  7.        TreeNode(int hash, K key, V val,Node<K,V> next){
  8.            super(hash, key, val, next);
  9.        }
  10.        // 返回根节点
  11.        finalTreeNode<K,V> root(){
  12.            for(TreeNode<K,V> r =this, p;;){
  13.                if((p = r.parent)==null)
  14.                    return r;
  15.                r = p;
  16.       }

LinkedList源码分析

构造方法

集合框架源码学习之HashMap(JDK1.8)
  1.    // 默认构造函数。
  2.    publicMore...HashMap(){
  3.        this.loadFactor = DEFAULT_LOAD_FACTOR;// all   other fields defaulted
  4.     }
  5.     // 包含另一个“Map”的构造函数
  6.     publicMore...HashMap(Map<?extends K,?extends V> m){
  7.         this.loadFactor = DEFAULT_LOAD_FACTOR;
  8.         putMapEntries(m,false);//下面会分析到这个方法
  9.     }
  10.     // 指定“容量大小”的构造函数
  11.     publicMore...HashMap(int initialCapacity){
  12.         this(initialCapacity, DEFAULT_LOAD_FACTOR);
  13.     }
  14.     // 指定“容量大小”和“加载因子”的构造函数
  15.     publicMore...HashMap(int initialCapacity,float loadFactor){
  16.         if(initialCapacity <0)
  17.             thrownewIllegalArgumentException("Illegal initial capacity: "+ initialCapacity);
  18.         if(initialCapacity > MAXIMUM_CAPACITY)
  19.             initialCapacity = MAXIMUM_CAPACITY;
  20.         if(loadFactor <=0||Float.isNaN(loadFactor))
  21.             thrownewIllegalArgumentException("Illegal load factor: "+ loadFactor);
  22.         this.loadFactor = loadFactor;
  23.         this.threshold = tableSizeFor(initialCapacity);
  24.     }
putMapEntries方法:
  1. finalvoid putMapEntries(Map<?extends K,?extends V> m,boolean evict){
  2.    int s = m.size();
  3.    if(s >0){
  4.        // 判断table是否已经初始化
  5.        if(table ==null){// pre-size
  6.            // 未初始化,s为m的实际元素个数
  7.            float ft =((float)s / loadFactor)+1.0F;
  8.            int t =((ft <(float)MAXIMUM_CAPACITY)?
  9.                    (int)ft : MAXIMUM_CAPACITY);
  10.            // 计算得到的t大于阈值,则初始化阈值
  11.            if(t > threshold)
  12.                threshold = tableSizeFor(t);
  13.        }
  14.        // 已初始化,并且m元素个数大于阈值,进行扩容处理
  15.        elseif(s > threshold)
  16.            resize();
  17.        // 将m中的所有元素添加至HashMap中
  18.        for(Map.Entry<?extends K,?extends V> e : m.entrySet()){
  19.            K key = e.getKey();
  20.            V value = e.getValue();
  21.            putVal(hash(key), key, value,false, evict);
  22.        }
  23.    }
  24. }

put方法

HashMap只提供了put用于添加元素,putVal方法只是给put方法调用的一个方法,并没有提供给用户使用。
  1. public V put(K key, V value){
  2.    return putVal(hash(key), key, value,false,true);
  3. }
  4. final V putVal(int hash, K key, V value,boolean onlyIfAbsent,
  5.                   boolean evict){
  6.    Node<K,V>[] tab;Node<K,V> p;int n, i;
  7.    // table未初始化或者长度为0,进行扩容
  8.    if((tab = table)==null||(n = tab.length)==0)
  9.        n =(tab = resize()).length;
  10.    // (n - 1) & hash 确定元素存放在哪个桶中,桶为空,新生成结点放入桶中(此时,这个结点是放在数组中)
  11.    if((p = tab[i =(n -1)& hash])==null)
  12.        tab[i]= newNode(hash, key, value,null);
  13.    // 桶中已经存在元素
  14.    else{
  15.        Node<K,V> e; K k;
  16.        // 比较桶中第一个元素(数组中的结点)的hash值相等,key相等
  17.        if(p.hash == hash &&
  18.            ((k = p.key)== key ||(key !=null&& key.equals(k))))
  19.                // 将第一个元素赋值给e,用e来记录
  20.                e = p;
  21.        // hash值不相等,即key不相等;为红黑树结点
  22.        elseif(p instanceofTreeNode)
  23.            // 放入树中
  24.            e =((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
  25.        // 为链表结点
  26.        else{
  27.            // 在链表最末插入结点
  28.            for(int binCount =0;;++binCount){
  29.                // 到达链表的尾部
  30.                if((e = p.next)==null){
  31.                    // 在尾部插入新结点
  32.                    p.next = newNode(hash, key, value,null);
  33.                    // 结点数量达到阈值,转化为红黑树
  34.                    if(binCount >= TREEIFY_THRESHOLD -1)// -1 for 1st
  35.                        treeifyBin(tab, hash);
  36.                    // 跳出循环
  37.                    break;
  38.                }
  39.                // 判断链表中结点的key值与插入的元素的key值是否相等
  40.                if(e.hash == hash &&
  41.                    ((k = e.key)== key ||(key !=null&& key.equals(k))))
  42.                    // 相等,跳出循环
  43.                    break;
  44.                // 用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表
  45.                p = e;
  46.            }
  47.        }
  48.        // 表示在桶中找到key值、hash值与插入元素相等的结点
  49.        if(e !=null){
  50.            // 记录e的value
  51.            V oldValue = e.value;
  52.            // onlyIfAbsent为false或者旧值为null
  53.            if(!onlyIfAbsent || oldValue ==null)
  54.                //用新值替换旧值
  55.                e.value = value;
  56.            // 访问后回调
  57.            afterNodeAccess(e);
  58.            // 返回旧值
  59.            return oldValue;
  60.        }
  61.    }
  62.    // 结构性修改
  63.    ++modCount;
  64.    // 实际大小大于阈值则扩容
  65.    if(++size > threshold)
  66.        resize();
  67.    // 插入后回调
  68.    afterNodeInsertion(evict);
  69.    returnnull;
  70. }

get方法

  1. public V get(Object key){
  2.    Node<K,V> e;
  3.    return(e = getNode(hash(key), key))==null?null: e.value;
  4. }
  5. finalNode<K,V> getNode(int hash,Object key){
  6.    Node<K,V>[] tab;Node<K,V> first, e;int n; K k;
  7.    if((tab = table)!=null&&(n = tab.length)>0&&
  8.        (first = tab[(n -1)& hash])!=null){
  9.        // 数组元素相等
  10.        if(first.hash == hash &&// always check first node
  11.            ((k = first.key)== key ||(key !=null&& key.equals(k))))
  12.            return first;
  13.        // 桶中不止一个节点
  14.        if((e = first.next)!=null){
  15.            // 在树中get
  16.            if(first instanceofTreeNode)
  17.                return((TreeNode<K,V>)first).getTreeNode(hash, key);
  18.            // 在链表中get
  19.            do{
  20.                if(e.hash == hash &&
  21.                    ((k = e.key)== key ||(key !=null&& key.equals(k))))
  22.                    return e;
  23.            }while((e = e.next)!=null);
  24.        }
  25.    }
  26.    returnnull;
  27. }

resize方法

进行扩容,会伴随着一次重新hash分配,并且会遍历hash表中所有的元素,是非常耗时的。在编写程序中,要尽量避免resize。
  1. finalNode<K,V>[] resize(){
  2.    Node<K,V>[] oldTab = table;
  3.    int oldCap =(oldTab ==null)?0: oldTab.length;
  4.    int oldThr = threshold;
  5.    int newCap, newThr =0;
  6.    if(oldCap >0){
  7.        // 超过最大值就不再扩充了,就只好随你碰撞去吧
  8.        if(oldCap >= MAXIMUM_CAPACITY){
  9.            threshold =Integer.MAX_VALUE;
  10.            return oldTab;
  11.        }
  12.        // 没超过最大值,就扩充为原来的2倍
  13.        elseif((newCap = oldCap <<1)< MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
  14.            newThr = oldThr <<1;// double threshold
  15.    }
  16.    elseif(oldThr >0)// initial capacity was placed in threshold
  17.        newCap = oldThr;
  18.    else{
  19.        signifies using defaults
  20.        newCap = DEFAULT_INITIAL_CAPACITY;
  21.        newThr =(int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
  22.    }
  23.    // 计算新的resize上限
  24.    if(newThr ==0){
  25.        float ft =(float)newCap * loadFactor;
  26.        newThr =(newCap < MAXIMUM_CAPACITY && ft <(float)MAXIMUM_CAPACITY ?(int)ft :Integer.MAX_VALUE);
  27.    }
  28.    threshold = newThr;
  29.    @SuppressWarnings({"rawtypes","unchecked"})
  30.        Node<K,V>[] newTab =(Node<K,V>[])newNode[newCap];
  31.    table = newTab;
  32.    if(oldTab !=null){
  33.        // 把每个bucket都移动到新的buckets中
  34.        for(int j =0; j < oldCap;++j){
  35.            Node<K,V> e;
  36.            if((e = oldTab[j])!=null){
  37.                oldTab[j]=null;
  38.                if(e.next ==null)
  39.                    newTab[e.hash &(newCap -1)]= e;
  40.                elseif(e instanceofTreeNode)
  41.                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
  42.                else{
  43.                    Node<K,V> loHead =null, loTail =null;
  44.                    Node<K,V> hiHead =null, hiTail =null;
  45.                    Node<K,V> next;
  46.                    do{
  47.                        next = e.next;
  48.                        // 原索引
  49.                        if((e.hash & oldCap)==0){
  50.                            if(loTail ==null)
  51.                                loHead = e;
  52.                            else
  53.                                loTail.next = e;
  54.                            loTail = e;
  55.                        }
  56.                        // 原索引+oldCap
  57.                        else{
  58.                            if(hiTail ==null)
  59.                                hiHead = e;
  60.                            else
  61.                                hiTail.next = e;
  62.                            hiTail = e;
  63.                        }
  64.                    }while((e = next)!=null);
  65.                    // 原索引放到bucket里
  66.                    if(loTail !=null){
  67.                        loTail.next =null;
  68.                        newTab[j]= loHead;
  69.                    }
  70.                    // 原索引+oldCap放到bucket里
  71.                    if(hiTail !=null){
  72.                        hiTail.next =null;
  73.                        newTab[j + oldCap]= hiHead;
  74.                    }
  75.                }
  76.            }
  77.        }
  78.    }
  79.    return newTab;
  80. }

HashMap常用方法测试

  1. package map;
  2. import java.util.Collection;
  3. import java.util.HashMap;
  4. import java.util.Set;
  5. publicclassHashMapDemo{
  6.    publicstaticvoid main(String[] args){
  7.        HashMap<String,String> map =newHashMap<String,String>();
  8.        // 键不能重复,值可以重复
  9.        map.put("san","张三");
  10.        map.put("si","李四");
  11.        map.put("wu","王五");
  12.        map.put("wang","老王");
  13.        map.put("wang","老王2");// 老王被覆盖
  14.        map.put("lao","老王");
  15.        System.out.println("-------直接输出hashmap:-------");
  16.        System.out.println(map);
  17.        /**
  18.         * 遍历HashMap
  19.         */
  20.        // 1.获取Map中的所有键
  21.        System.out.println("-------foreach获取Map中所有的键:------");
  22.        Set<String> keys = map.keySet();
  23.        for(String key : keys){
  24.            System.out.print(key+"  ");
  25.        }
  26.        System.out.println();//换行
  27.        // 2.获取Map中所有值
  28.        System.out.println("-------foreach获取Map中所有的值:------");
  29.        Collection<String> values = map.values();
  30.        for(String value : values){
  31.            System.out.print(value+"  ");
  32.        }
  33.        System.out.println();//换行
  34.        // 3.得到key的值的同时得到key所对应的值
  35.        System.out.println("-------得到key的值的同时得到key所对应的值:-------");
  36.        Set<String> keys2 = map.keySet();
  37.        for(String key : keys2){
  38.            System.out.print(key +":"+ map.get(key)+"   ");
  39.        }
  40.        /**
  41.         * 另外一种不常用的遍历方式
  42.         */
  43.        // 当我调用put(key,value)方法的时候,首先会把key和value封装到
  44.        // Entry这个静态内部类对象中,把Entry对象再添加到数组中,所以我们想获取
  45.        // map中的所有键值对,我们只要获取数组中的所有Entry对象,接下来
  46.        // 调用Entry对象中的getKey()和getValue()方法就能获取键值对了
  47.        Set<java.util.Map.Entry<String,String>> entrys = map.entrySet();
  48.        for(java.util.Map.Entry<String,String> entry : entrys){
  49.            System.out.println(entry.getKey()+"--"+ entry.getValue());
  50.        }
  51.        /**
  52.         * HashMap其他常用方法
  53.         */
  54.        System.out.println("after map.size():"+map.size());
  55.        System.out.println("after map.isEmpty():"+map.isEmpty());
  56.        System.out.println(map.remove("san"));
  57.        System.out.println("after map.remove():"+map);
  58.        System.out.println("after map.get(si):"+map.get("si"));
  59.        System.out.println("after map.containsKey(si):"+map.containsKey("si"));
  60.        System.out.println("after containsValue(李四):"+map.containsValue("李四"));
  61.        System.out.println(map.replace("si","李四2"));
  62.        System.out.println("after map.replace(si, 李四2):"+map);
  63.    }
  64. }
本站所有文章均来自互联网,如有侵权,请联系站长删除。极客文库 » 集合框架源码学习之HashMap(JDK1.8)
分享到:
赞(0)

评论抢沙发

评论前必须登录!