HashMap

HashMap

HashMap 是java中常见的容器，存储的是一个个key-value格式的键值对 ，被称为Entry采用哈希方式来实现.HashMap对Entry进行了扩展（称作Node，是一个单链表的结构），成为了链表或者树的结构并存储在了HashMap容器里。所以可以说在1.8中，HashMap底层是数组＋链表＋红黑树。

一、HashMap结构

二、HashMap的组成

//是hashMap的最小容量16，容量就是数组的大小也就是变量，transient Node<K,V>[] table。
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    //最大数量，该数组最大值为2^31一次方。
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //默认的加载因子，如果构造的时候不传则为0.75
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //一个位置里存放的节点转化成树的阈值，也就是8，比如数组里有一个node，这个 
      // node链表的长度达到该值才会转化为红黑树。
    static final int TREEIFY_THRESHOLD = 8;
    //当一个反树化的阈值，当这个node长度减少到该值就会从树转化成链表
    static final int UNTREEIFY_THRESHOLD = 6;
    //满足节点变成树的另一个条件，就是存放node的数组长度要达到64
    static final int MIN_TREEIFY_CAPACITY = 64;
    //具体存放数据的数组
    transient Node<K,V>[] table;
    //entrySet，一个存放k-v缓冲区
    transient Set<Map.Entry<K,V>> entrySet;
    //size是指hashMap中存放了多少个键值对
    transient int size;
    //对map的修改次数
    transient int modCount;
    //加载因子
    final float loadFactor;

table是用来存放数据（也叫做桶），可见HashMap容器，是由多个Node组成的，而Node中有一个子类TreeNode是一个红黑树的类型，所以HashMap存放的Node的形式，可以是链表（Node）也可以是树状（TreeNode）。

Node

//Node是单向链表，它实现了Map.Entry接口
static class Node<k,v> implements Map.Entry<k,v> {
    final int hash;
    final K key;
    V value;
    Node<k,v> next;
    //构造函数Hash值 键 值 下一个节点
    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; }
    public final V getValue()      { return value; }
    public final String toString() { return key + = + value; }
 
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
 
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }
    //判断两个node是否相等,若key和value都相等，返回true。可以与自身比较为true
    public final boolean equals(Object o) {
        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;
    }

TreeNode

//红黑树
static final class TreeNode<k,v> extends LinkedHashMap.Entry<k,v> {
    TreeNode<k,v> parent;  // 父节点
    TreeNode<k,v> left; //左子树
    TreeNode<k,v> right;//右子树
    TreeNode<k,v> prev;    // needed to unlink next upon deletion
    boolean red;    //颜色属性
    TreeNode(int hash, K key, V val, Node<k,v> next) {
        super(hash, key, val, next);
    }
 
    //返回当前节点的根节点
    final TreeNode<k,v> root() {
        for (TreeNode<k,v> r = this, p;;) {
            if ((p = r.parent) == null)
                return r;
            r = p;
        }
    }

而由源码可知：

static final int TREEIFY_THRESHOLD = 8;
static final int MIN_TREEIFY_CAPACITY = 64;
static final int UNTREEIFY_THRESHOLD = 6;

当链表的长度到了8这个阈值时，且存放Node的数组长度达到64，结构就会由链表变为树状。当树的节点数量小于6时，则会重新变成单向链表的数据结构

三、HashMap构造函数

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0) // 容量不能为负数
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    //当容量大于2^31就取最大值1<<31; 
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    //当前数组table的大小，一定是是2的幂次方
    // tableSizeFor保证了数组一定是是2的幂次方，是大于initialCapacity最结进的值。
    this.threshold = tableSizeFor(initialCapacity);
}

扩容

Java中数组时无法自动扩容的，在HashMap中是使用创建了一个新的数组去代替原来的数组，并且对原数组的所有数据重新计算并插入新的数组中，然后指向新的数组。如果扩容前就达到了最大值（2^31）则将threshold修改为2的31次方了，表明不进行扩容了。
当hash表的大小超过了扩容阈值时，则会进行扩容（扩容阈值=容量 x 加载因子 初始容量为16，扩容因子没有传值的时候，默认为0.75）

四、方法

我们开发中常用的方法put是这个样子的

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

而putVal这个方法，是HashMap使用的put的方法：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //首次初始化的时候table为null
    if ((tab = table) == null || (n = tab.length) == 0)
    //对HashMap进行扩容
        n = (tab = resize()).length;
    //根据hash值来确认存放的位置。如果当前位置是空直接添加到table中
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
    //如果存放的位置已经有值
        Node<K,V> e; K k;
        //确认当前table中存放键值对的Key是否跟要传入的键值对key一致
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //如果是红黑树，调用红黑树的putTreeVal方法 
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {//如果hashCode一样的两个不同Key就会以链表的形式保存
          //是链表，遍历，注意e = p.next这个一直将下一节点赋值给e，直到尾部，注意开头是++binCount
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //当链表长度大于等于7，插入第8位，树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st    判断链表长度是否大于8
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;  //替换新的value并返回旧的value
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize(); //如果当前HashMap的容量超过threshold则进行扩容
    afterNodeInsertion(evict);
    return null;
}

先通过key计算出来hash code，（通过这个hash code来确定存放的地址），如果当前地址没有值，则插入。如果有值，则去判断当前key和第一个key是否相等，相等则赋值，不想等，则去判断是否是红黑树，否则则是链表然后遍历去赋值（其中会去判断链表长度是否到了8这个阈值，如果是的话则树化）。

get

 public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

getNode

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    //先判断表不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        //这一行是找到要查询的Key在table中的位置，table是存放HashMap中每一个Node的数组。
        (first = tab[(n - 1) & hash]) != null) {
        //Node可能是一个链表或者树，先判断根节点是否是要查询的key,就是根节点，方便后续遍历Node写法并且
        //对于只有根节点的Node直接判断
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        //有子节点
        if ((e = first.next) != null) {
            //红黑树查找
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                //链表查找
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            }
            //遍历链表，当链表后续为null则推出循环
            while ((e = e.next) != null);
        }
    }
    return null;
}

get(key)方法时获取key的hash值，计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等，不等就判断是否是红黑树，是的话，则从根结点开始进行匹配，有则返回数据，没有则返回null。如果是链表的话，则循环遍历链表找到相同的key值返回对应的Value值即可。

1.7/1.8区别

1、底层数据结构：1.7数组+链表 1.8数组+链表+红黑树
2、resize（）方法，在1.8中判断表为空则去创建，不为空则扩容。1.7中，只负责扩容，有一个inflateTable()负责创建表
3、1.7采用头插法，调用addEntry()方法，将节点添加到链表头部。1.8则直接将节点添加到链表的尾部（不易出现环形链表的原因）。
4、1.7在插入数据之前扩容，而1.8插入数据成功之后扩容

总结：

1、HashMap是无序性的，如果key一样则去覆盖value，key是不可重复的，对应的累需要重写hashCode 和 equals
2、key-value允许为null，但是空key只有一个，放在第一位。
3、初始化容量为16，默认加载因子为0.75，扩容一定是是2的倍数
4、可序列化，线程不安全
5、遍历相对慢，但是插入删除快