1、 HashMap原理分析

1.1、 HashMap继承体系

1.2、Node数据结构分析

1.3、底层储存结构

1.3.1、put方法分析

2.1.1、public HashMap(int initialCapacity, float loadFactor)

2.1.2、 public HashMap(int initialCapacity)

2.1.3、public HashMap()

2.1.4、public HashMap(Map m)

1、 HashMap原理分析

1.1、 HashMap继承体系

HashMap继承体系源码

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

1.2、Node数据结构分析

HashMap内部类Node的源码

//静态内部类  实现了Map.Entry这个接口  K key,V value 泛型
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;//存放经过HashMap内的hash函数处理后的k的hash值
        final K key;//存放Key值
        V value;//存放Value值
        Node<K,V> next;//可能是红黑树或链表 由树化条件处理后决定

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }//返回key值
        public final V getValue()      { return value; }//返回value值
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {//返回Node的hashCode  保证了key唯一性
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {//重写equal如果key和value完全一致就返回true
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

Map.Entry接口

interface Entry<K,V> {
      
        K getKey();

     
        V getValue();

     
        V setValue(V value);

        boolean equals(Object o);

        int hashCode();

        //后面几个方法主要为实现排序这里不再解释
        public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }


        public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }


        public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
        }
    }

1.3、底层储存结构

当Node数组长度达到且超过64时，且链表长度达到8时，再插入一个元素时，就会升级成红黑树。

1.3.1、put方法分析

如果我们插入一个键值对，它经过put方法，总共要经过5个步骤：

map.put(1,2)
获取键值1的hash值
经过hash值扰动函数，使此hash值更散列
构造Node对象
经过路由寻址算法计算出数组的索引即存放的位置（(数组的长度-1)&key经过扰动后hash值）

1.4、hash碰撞

既然说到了hash碰撞就在扯一下HashMap是如何保证key的唯一性的。

1.4.1、key值的唯一性

从底层源码中我们可以知道HashMap重写了hashCode和equals方法,通过这两个方法来保证了key的唯一性。下面分析下源码。

//hashcode方法 
public final int hashCode() {
//通过把key和value的hashCode异或 如果key和value有一个不一样返回的hashCode就不一样
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }
//equals方法

 public final boolean equals(Object o) {
            if (o == this)//如果是基本数据类型比较到这里就可以返回true
                return true;
            //如果为false 有两种情况
            //1、基本数据类型 2、引用数据类型 所以说不确定是否为false还是true
            if (o instanceof Map.Entry) {//o判断o是否为实现Map.Entry接口
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&//如果key和value完全一致则返回true
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }

1.4.2、hash碰撞

由于在路由寻址时，是根据key的hashCode来计算数组的索引的，是通过hashCode值随机取的索引总会有相同的时候，这时候就被称为hash碰撞。

 //通过让key和key的右移16的值异或这样就能保证前16位也能参与路由寻址
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }


  public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
   //路由寻址是通过key的经过hash扰动函数处理的hash值与数组长度-1 进行与运算

1.5、链化

所谓链化就是数组里存放不再是单纯的一个继承object的数据类型了，而是一个链表和红黑树，这样的结构，结合了数组和链表的优点，组成的散列表的数据结构。下面来说，HashMap是如何判断在什么时候才进行链化。

在HashMap中有几个静态常量参数先介绍下

   //默认数组容量 2^4
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
    //最大数组容量
    static final int MAXIMUM_CAPACITY = 1 << 30;

   //用来计算阈值的一个默认加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

   //树化时链表长度也要达到8
    static final int TREEIFY_THRESHOLD = 8;
    //扩容的默认阈值
    static final int UNTREEIFY_THRESHOLD = 6;

    //最小树化(转成红黑树)数组的容量
    static final int MIN_TREEIFY_CAPACITY = 64;

当出现hash碰撞时，就会开始链表化了。还有一个词叫树化，也就是转为红黑树，达到树化所需要的条件就是数组容量达到64或超过64，且链表长度超过8时，就会开始树化了。