• HashMap源码分析(jdk 8)


    HashMap源码分析(jdk 8)

    1.创建一个map对象

    HashMap map = new HashMap();	//底层并没有创建一个长度为16的数组
    

    底层实现HashMap.java

    transient Node<K,V>[] table;	//底层数组类型为Node,而非Entry,与jdk 7没有太大区别,就是换了个名字,该有的属性都有。
    
    static class Node<K,V> implements Map.Entry<K,V> {		//这里实现了Entry,本质上还是Entry
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
        ...
    }    
    

    第一步:调用无参构造器

    public HashMap() {
            this.loadFactor = DEFAULT_LOAD_FACTOR; 	//加载因子被赋值为0.75
        }
    

    DEFAULT_LOAD_FACTOR:默认的加载因子:0.75

    2.添加数据,put( )方法

    map.put(key1,value1);
    

    底层实现HashMap.java

    第一步:第一次调用put()方法

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    

    第二步:调用putVal()

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)		//首次执行时(tab = table) == null初始化后肯定为true
            n = (tab = resize()).length;						//resize()进行扩容
        if ((p = tab[i = (n - 1) & hash]) == null)				//通过&运算(某种算法)算出在当前数组中的存放位置
        	//1.i位置上的元素p为空时,进行添加
            tab[i] = newNode(hash, key, value, null);
        else {
        	//2.i位置上的元素p不为空时
            Node<K,V> e; K k;
            //key1的哈希值和已经存在的数据p的哈希值相同且key的地址相同或value相同时
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //将i位置上的数据p存到e中 
                e = p;					
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
           /*进入else的两种情况:(1)key1的哈希值和已经存在的数据p的哈希值相同即p.hash == hash为true,
           						但(k = p.key) == key || (key != null && key.equals(k)))为false时
           				  	  (2)key1的哈希值和已经存在的数据p的哈希值不相同即p.hash == hash为false时
           	*/
           else {		
                for (int binCount = 0; ; ++binCount) {			//遍历位置i上的链表
                    if ((e = p.next) == null) {					//i位置上只有一个p元素时,进行添加	
                    	//将添加的数据放在p的下一个
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) //当链表长度大于8时,将链表变成一个树的结构
                            treeifyBin(tab, hash);
               *****************************************************
               //调用treeifyBin方法
               final void treeifyBin(Node<K,V>[] tab, int hash) {
                    int n, index; Node<K,V> e;
                    
                    //tab == null为false,当前数组长度 < 64时,进行扩容
                    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)	
                        resize();						//扩容
                        
                        //当前数组长度 > 64时,此时此索引位置上的所有数据改为使用【红黑树】存储。
                    else if ((e = tab[index = (n - 1) & hash]) != null) {		
                        TreeNode<K,V> hd = null, tl = null;
                        do {
                            TreeNode<K,V> p = replacementTreeNode(e, null);
                            if (tl == null)
                                hd = p;
                            else {
                                p.prev = tl;
                                tl.next = p;
                            }
                            tl = p;
                        } while ((e = e.next) != null);
                        if ((tab[index] = hd) != null)
                            hd.treeify(tab);
                    }
        }
               *****************************************************
                        break;
                    }
                    if (e.hash == hash &&					//i位置上不止一个p元素,比较p的next的哈希值,equals()
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;								//返回true时,终止,执行if (e != null)进行又替换操作
                    p = e;									//之前e = p.next,现在p = e;再次循环
                }
            }
            if (e != null) { 							// 进行替换的逻辑
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;					//将添加的value替换原来e(也就是p)的value
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
    

    第一种情况i位置上的数据为空即(p = tab[i = (n - 1) & hash]) == null时,数据key1-value1添加成功。

    第二种情况i位置上的数据不为空,key1的哈希值和已经存在的数据的哈希值都不相同,进入else,遍历链表,

    ​ ​ ​ ​ ​ ​ ​ ​ ​ (1)如果链表只有i位置上一个p元素,则数据key1-value1添加成功,添加在p的next。

    ​ ​ ​ ​ ​ ​ ​ ​ ​ (2)如果链表不止一个元素,则挨个儿进行比较哈希值:

    ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​  1>如果哈希值相同【即e.hash == hash为true】:

    ​​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ 若​equals()返回true【即(k = e.key) == key || (key != null && key.equals(k)))为true】,则进行替换
    ​​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ 若equals()返回false【即(k = e.key) == key || (key != null && key.equals(k)))为false】,则继续遍历

    ​  ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​2>如果哈希值不同【即e.hash == hash为false】,则继续遍历

    第三种情况i位置上的数据不为空,key1的哈希值和已经存在的数据的哈希值相同即p.hash == hash为true,

    1. (e.key = key) == key) || key.equals(k)返回false,进入else,遍历链表,后续与第二种情况相同

    2. ((k = p.key) == key || (key != null && key.equals(k)))为true,执行e = p;(将i位置上的数据p存到e中 ),所以e != null为true,进行替换操作。

    第三步:调用resize()

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;								//oldTab为null
        int oldCap = (oldTab == null) ? 0 : oldTab.length;		//oldCap为0
        int oldThr = threshold;									//oldThr为0
        int newCap, newThr = 0;
        
        if (oldCap > 0) {										//false
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        
        else if (oldThr > 0) 									//false
            newCap = oldThr;
        
        else {               
            newCap = DEFAULT_INITIAL_CAPACITY;					//默认初始化容量:16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//临界值:newThr(12) = 0.75 * 16 
        }
        if (newThr == 0) {										//newThr为12,所以false
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;										//将12赋给临界值
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];		//创建了长度为16的数组newTab
        table = newTab;											//将创建好的数组赋给当前的数组table
        ...
        return newTab;											//返回数组newTab
    }
    
    相信自己,你能行!!!
  • 相关阅读:
    leetcode — spiral-matrix-ii
    leetcode — spiral-matrix
    leetcode — maximum-subarray
    leetcode — n-queens
    leetcode — powx-n
    leetcode — anagrams
    bzoj 2194: 快速傅立叶之二 FFT
    bzoj 4503 两个串 快速傅里叶变换FFT
    Codeforces 762D Maximum path 动态规划
    Codeforces 762C Two strings 字符串
  • 原文地址:https://www.cnblogs.com/byd-hold-on/p/HashMap.html
Copyright © 2020-2023  润新知