Java HashMap 源码自学分析

最新推荐文章于 2024-05-03 08:47:01 发布

Sylvan 于子航

最新推荐文章于 2024-05-03 08:47:01 发布

阅读量88

点赞数

文章标签： hashmap

本文链接：https://blog.csdn.net/sylvanyu/article/details/115446266

版权

HashMap 源码分析学习

HashMap简介
底层数据结构
put插入原理
HashMap常量，成员变量的作用
HashMap构造函数

HashMap简介

Map集合子类：Map集合子类：HashTable 、 HashMap 、 TreeMap 、 LinkedHashMap。
HashMap 是java中Map集合类的一个实现子类；它以key value键值对的形式存储对象。
key不可以重复，value可以重复
允许key，value为null；

底层数据结构

HashMap 底层数据结构时基于：数组+链表+红黑树实现的；

put插入原理

在这里插入图片描述

判断数组是否为空，为数组进行初始化
不为空，计算插入节点的hash值，通过（n-1)&hash（其实这个就是hash值%数组长度）计算出当前元素应该插入的下标 i；
查看table[i]是否已经存在数据，没有数据就构造一个Node节点存放在table[i]中；
如果已经存在数据，说明发生了hash冲突，判断key是否相等，如果相等，用新的value替换旧数据；
如果不相等，判断当前节点是不是树节点，如果是，创建新的节点插入到红黑树中。
如果不是树节点，创建普通的node加入链表；判断链表长度是否大于8，如果是，链表转为红黑树。
插入完成后判断当前节点个数是否大于阈值Threshold，如果是，扩容原数组的2倍

HashMap常量，成员变量的作用

//创建HashMap时，未指定初始容量的情况下，默认容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //16
//HashMap的默认最大容量
static final int MAXIMUM_CAPACITY = 1 << 30; //十亿多
//默认的加载因子，用加载因子*数组容量来判断是否需要扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当hash冲突的节点个数（链表长度）长度大于8时变成红黑树
static final int TREEIFY_THRESHOLD = 8;
//当红黑树的节点个数小于6时，转变为链表
static final int UNTREEIFY_THRESHOLD = 6;
//当需要解决hash冲突的链表转为红黑树时，需要判断此时的数字组容量，若容量小于MIN_TREEIFY_CAPACITY导致的hash冲突太多，则不进行链表转为红黑树的操作，而是resize()函数对HashMap进行扩容
static final int MIN_TREEIFY_CAPACITY = 64;
//声明节点数组
transient Node<K,V>[] table;
//HashMap中的元素个数
transient int size;
//hashMap结构被修改的次数，值的覆盖不计数
transient int modCount;
//阈值，用来控制数组扩容 threshold = 加载因子*数组容量
int threshold;

HashMap构造函数

	//有参构造器： 参数：容量，加载因子
    public HashMap(int initialCapacity, float loadFactor) {
     	//当设定的容量的数组容量为负数，抛出异常
        if (initialCapacity < 0){
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        }
        //如果设定的容量大于了数组的最大长度，则设容量为最大容量
        if (initialCapacity > MAXIMUM_CAPACITY){
        	initialCapacity = MAXIMUM_CAPACITY;
        }
        
        //如果设定的加载因子<=0 或者不是一个数字，抛出异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor)){
            throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
        }
        //设置加载因子为当前传入加载因子
        this.loadFactor = loadFactor;
        //当前的threshhold为大于初始容量的2的整数次方
        this.threshold = tableSizeFor(initialCapacity);
    }
	
	//如果之传入了容量，就是用默认的加载因子0.75
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

	//如果用的无参构造器，当前的加载因子为0.75  
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; 
    }

tableSizeFor（）方法

上述的全参构造器中，如果传入了参数，要调用这个方法来计算threshhold（初始容量存在了threshold中）

这个方法详细解读：

用传入的cap值 - 1
然后 | = 自身右移 1 2 4 8 16

例子：如果传入的是10 ，那么返回16

static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

put解析

//put方法，在方法中调用hash（key）方法，以及putVal（）方法
//hash(key)是用来计算key的hash值的
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
//hash()方法拿到了key的hashcode，然后让hashcode的高16位和低十六位做异或操作，目的是降低hash碰撞，越分散越好。 位运算符运算效率更高
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

//putVal方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        Node<K,V>[] tab; //声明tab
        Node<K,V> p; //声明节点
        int n; //声明n表示当前数组长度，
        int i; //i为元素插入索引位置
        tab = table;
        n = tab.length;
        if (tab == null || n == 0){
			//如果当前tab是空数组 或 tab数组的长度 = 0
        	//进行扩容 初始化为16
        	 n = (tab = resize()).length;
		}
            //如果当前位置为null，创建新的节点，存入i位置
        if ((p = tab[i = (n - 1) & hash]) == null)
        
            tab[i] = newNode(hash, key, value, null);
            
        else {
        	//如果当前位置已经有p节点
            Node<K,V> e; K k;
            //如果key相等，并且hash值相等
            if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
                e = p; //将e指向p
             //如果p是树节点，加入树节点
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else { //不是树节点，加入链表
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //如果链表长度大于8. 变红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
               
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
			//将需要覆盖value值的节点，覆盖新值
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
      // 如果当前节点数+1 大于 threshold，进行扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

Resize

   final Node<K,V>[] resize() {
   		//用table赋值给old数组
        Node<K,V>[] oldTab = table;
        //old数组是否为null，如果是返回0，不是返回长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //old的阈值
        int oldThr = threshold;
        //设置new容量thr为0
        int newCap, newThr = 0;
        //如果old容量>0，
        if (oldCap > 0) {
        	//若果大于最大长度，设置thr为Max value
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                //返回old数组
                return oldTab;
            }else if ((newCap = oldCap << 1) <MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)
            //如果扩容2倍扩容数组 < 默认最大容量 && old容量 > 16
            //newThr等于oldThr * 2
                newThr = oldThr << 1; 
       		 } else if (oldThr > 0) 
            	newCap = oldThr;
       } else {    
        //如果oldCap <=0 ， 容量为16 threshold  = 12      
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }