HashMap源码

核心方法

• 构造方法
  HashMap有四个构造方法。

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;

对于无参构造都是默认值。容量也就是桶（属性table数组的长度）的个数，16。默认加载因子是0.75。

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)                          --------------------》对初始容量校验
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)          ----------------------》如果初始容量大于2的30次方，就设置为2的30次方
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))           ----------------------》校验加载因子
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);      -------------------------------》这里保证初始容量必须是2的幂
    }
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

对于传入int和int、float参数都是初始化容量和加载因子，初始容量必须2的幂。

public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

HashMap还可以将map对象作为参数传入，将map的键值对都放到这个新的HashMap中

put

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

对于put方法是讲key和value存到HashMap中，源码中可以看到调用的是如下方法，下面说的桶是table数组的一个具体值，就是table[i]

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) ---------------》判断table这个属性是否为null或容量（桶）为0，默认第一次put都会进入这个判断（因为构造方法只初始化了加载因子）
            n = (tab = resize()).length;            ---------------》这个resize就可以获得一个默认长度（桶）为16的Node数组（Node是链表，有时就可以说HashMap就是数组加链表）
        if ((p = tab[i = (n - 1) & hash]) == null)   ------------》根据key得到的hash值和容量（桶个数也就是属性table这个数组长度）判断键值对对象应该放到哪，第一次进来肯定是在桶的相应位置没有值的，会进入这个判断
            tab[i] = newNode(hash, key, value, null);  ------------》在对应桶的位置放入一个new出来的节点（在桶放入链表）p也是这个值
        else {                        ---------------》这个else表示在对应桶的位置已经有值了
            Node<K,V> e; K k;
            if (p.hash == hash &&           ----》判断是不是同一个对象
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;							
            else if (p instanceof TreeNode)  -----》判断是不是TreeNode（红黑树），HashMap不能按顺序（大小有TreeMap，存放顺序有LinkedHashMap）取值。
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {             -----------》正常情况都不会去上面两个地方，会进入这里
                for (int binCount = 0; ; ++binCount) { ---------相当于不满足t跳出条件会一直循环
                    if ((e = p.next) == null) {  ---------------判断p这个位置的桶放的next是不是有东西，没有就赋值
                        p.next = newNode(hash, key, value, null); -------------没有就将这个要存放的键值对放到
                        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; ---------------------》和 if ((e = p.next) == null)配合使用，一直循环去找到next为null的最后一个，然后在它的next存放传过来的键值对
                }
            }
            if (e != null) { // existing mapping for key ----------------》判断是不是key已存在
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;  -------------》将value值替换
                afterNodeAccess(e);
                return oldValue; --------------------》put方法会返回一个旧的value值，没有就是下面的null
            }
        }
        ++modCount; -------------》属性modCount（用于记录修改次数）加一
        if (++size > threshold)--------------》判断键值对（这里是键值对，不是桶的个数）的数量大于阈值，阈值默认是16*0.75=12
            resize();------------》如果是就扩容
        afterNodeInsertion(evict);
        return null;
    }

键值对（这里是键值对，不是桶的个数）的数量大于阈值，阈值默认是16*0.75=12，就会扩容

get

get方法利用key找到相应的value

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

调用的是getNode方法获取一个节点Node，并且赋值给e,然后获取e的value

 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 &&    --------------》判断table数组是否为空，是否有值
            (first = tab[(n - 1) & hash]) != null) {               -------------》根据传过来的key和key的hash，判断对应的桶是否为空
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))    ----》判断first这个节点的key是否和传过来的相等
                return first;                         ------------如果相等就返回这个值
            if ((e = first.next) != null) {       ------如果还可以遍历，也就是链表next还有值
                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;
                } while ((e = e.next) != null); --------------》以dowhile的方式一直去找的相等的key值，然后返回
            }
        }
        return null; -------------》如果没有就会给一个null，也就是说传入一个没有存过的key找它的value值，不会报错而是给一个null
    }

remove

public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

remove移除键值对，返回一个value值，调用了removeNode方法。
和get方法类似。这里就不拿源码说了。
相当于将传入的key值找到table数组桶位置，然后怎么操作链表的移除，这里就怎么移除，注意的是，在找到桶之后，要先看是否已经从链表变成红黑树了，变成红黑树就以红黑树的规则移除。

其他方法

• keyset和values
  对应的可以拿到所有的key或者value，因为key不会重复，所以是set，而对于value可以重复便就是Collection类型。
  注意的是这两个方法拿到就是key和value真实地址值，用这两个方法获取的set和collection是不可以使用add方法的（会报UnsupportedOperationException异常）
  可以使用keyset方法和get（key）去遍历map，因为利用keyset就拿到了所有的key，然后利用key去拿到相应的value值
• entrySet()
  和keyset方法类似，都是set，只不过一个存放是key，一个是entry（可以看成是一个键值对对象，封装了key和value）
  也可以遍历map

Set<Map.Entry<Integer,Integer>> entries = map.entrySet();

• forEach(BiConsumer<? super K, ? super V> action)
  如果使用上面几个方法遍历会比较麻烦，提供foreach方法，利用函数式接口（Lambda表达式）

 map.forEach((k,v)->System.out.println(k+" "+v))；

• size
  返回键值对数量

核心属性

• Set<Map.Entry<K,V>> entrySet
  这个属性默认是空，只有调用了entrySet()才会赋值。

public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }

EntrySet是HashMap的内部类继承了AbstractSet，重写一些方法，如iterator()方法（返回一个迭代器），但还有一些方法没有重写，如add方法，add方法在AbstractCollection抽象类实现了（AbstractSet继承了AbstractCollection），仅仅是抛出一个异常

 public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

类似的还有keySet和values属性（他们在HashMap父类AbstractMap中定义），默认也是为null，调用相应方法再赋值

public Set<K> keySet() {
        Set<K> ks = keySet;
        if (ks == null) {
            ks = new KeySet();
            keySet = ks;
        }
        return ks;
    }
    public Collection<V> values() {
        Collection<V> vs = values;
        if (vs == null) {
            vs = new Values();
            values = vs;
        }
        return vs;
    }

• Node<K,V>[] table
  table属性可以看成一个链表的数组，而链表装的是键值对，在jdk8以后链表长度超过8就会变成红黑树
  所以有时会说HashMap就是数组加链表
• int threshold
  阈值，它等于table数组长度乘以loadFactor，然后强转为int，源码如下

newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); --------》这里阈值就是12

• int size
  size表示键值对的个数，put方法会加1，remove会减一
  当size大于阈值就会扩容，源码如下

 if (++size > threshold)
            resize();

• float loadFactor
  与table长度一起设置阈值，默认0.75。在构造方法，可以设置loadFactor和table数组长度。
• int modCount
  记录修改次数