HashMap类

• JDK1.2版本，线程不安全，运行效率快；允许用null作为key或是value。

• 初始容量16，加载因子0.75。最大容量为2³⁰

1. HashMap

HashMap<Student, String> hashMap = new HashMap<Student, String>();
Student s1 = new Student("tang", 36);
Student s2 = new Student("yu", 101);
Student s3 = new Student("he", 10);
// 1.添加元素
hashMap.put(s1, "成都");
hashMap.put(s2, "杭州");
hashMap.put(s3, "郑州");
// key重复时，会更新值
hashMap.put(s3, "上海");
// 注：假如相同属性便认为是同一个对象，怎么修改？---> 重写hashCode()和equals()方法
hashMap.put(new Student("he", 10), "上海");
System.out.println(hashMap.toString());
// 2.删除元素
hashMap.remove(s3);
System.out.println(hashMap.toString());
// 3.遍历
// 3.1 使用keySet()遍历
for (Student key : hashMap.keySet()) {
  System.out.println(key + " " + hashMap.get(key));
}
// 3.2 使用entrySet()遍历
for (Entry<Student, String> entry : hashMap.entrySet()) {
  System.out.println(entry.getKey() + " " + entry.getValue());
}
// 4.判断
// 注：同上
System.out.println(hashMap.containsKey(new Student("he", 10)));
System.out.println(hashMap.containsValue("成都"));

2. HashMap源码分析

2.1. 构造方法

initialCapacity初始容量

loadFactor加载因子

public HashMap(int initialCapacity, float loadFactor) {
  if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal initial capacity: " +
                                       initialCapacity);
  if (initialCapacity > MAXIMUM_CAPACITY)
    initialCapacity = MAXIMUM_CAPACITY;
  if (loadFactor <= 0 || Float.isNaN(loadFactor))
    throw new IllegalArgumentException("Illegal load factor: " +
                                       loadFactor);
  this.loadFactor = loadFactor;
  this.threshold = tableSizeFor(initialCapacity);
}

public HashMap(int initialCapacity) {
  this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap() {
  this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

2.2. 常用方法

• 默认初始化容量：static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
  • 数组最大容量：static final int MAXIMUM_CAPACITY = 1 << 30;
• 默认加载因子：static final float DEFAULT_LOAD_FACTOR = 0.75f;
• 链表调整为红黑树的链表长度阈值（JDK1.8+）：static final int TREEIFY_THRESHOLD = 8;
• 红黑树调整为链表的链表长度阈值（JDK1.8+）：static final int UNTREEIFY_THRESHOLD = 6;
• 链表调整为红黑树的数组最小阈值（JDK1.8+）：static final int MIN_TREEIFY_CAPACITY = 64;
• HashMap存储的数组：transient Node<K,V>[] table;
• HashMap存储的元素个数：transient int size;

• 默认加载因子是什么？
  • 就是判断数组是否扩容的一个因子。假如数组容量为100，如果HashMap的存储元素个数超过了100*0.75=75，那么就会进行扩容。
• 链表调整为红黑树的链表长度阈值是什么？
  • 假设在数组中下标为3的位置已经存储了数据，当新增数据时通过哈希码得到的存储位置又是3，那么就会在该位置形成一个链表，当链表过长时就会转换成红黑树以提高执行效率，这个阈值就是链表转换成红黑树的最短链表长度；
• 红黑树调整为链表的链表长度阈值是什么？
  • 当红黑树的元素个数小于该阈值时就会转换成链表。
• 链表调整为红黑树的数组最小阈值是什么？
  • 并不是只要链表长度大于8就可以转换成红黑树，在前者条件成立的情况下，数组的容量必须大于等于64才会进行转换。

HashMap的数组table存储的就是一个个的Node类型，很清晰地看到有一对键值，还有一个指向next的指针

static class Node<K,V> implements Map.Entry<K,V> {
  final K key;
  V value;
  Node<K,V> next;
}

之前的代码中在new对象时调用的是HashMap的无参构造方法，该构造方法的源码

public HashMap() {
  this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

只是赋值了一个默认加载因子；而在上文我们观察到源码中table和size都没有赋予初始值，说明刚创建的HashMap对象没有分配容量，并不拥有默认的16个空间大小，这样做的目的是为了节约空间，此时table为null，size为0。

当我往对象里添加元素时调用put方法

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

ut方法把key和value传给了putVal，同时还传入了一个hash(Key)所返回的值，这是一个产生哈希值的方法，再进入到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)
    n = (tab = resize()).length;
  if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);
  else{
    //略
  }
}

这里面创建了一个tab数组和一个Node变量p，第一个if实际是判断table是否为空，而现在只关注刚创建HashMap对象时的状态，此时tab和table都为空，满足条件，执行内部代码，这条代码其实就是把resize()所返回的结果赋给tab，n就是tab的长度，resize顾名思义就是重新调整大小。查看resize()源码（部分）：

final Node<K,V>[] resize() {
  Node<K,V>[] oldTab = table;
  int oldCap = (oldTab == null) ? 0 : oldTab.length;
  int oldThr = threshold;
  if (oldCap > 0);
  else if (oldThr > 0);
  else {               // zero initial threshold signifies using defaults
    newCap = DEFAULT_INITIAL_CAPACITY;
    newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
  } 
  @SuppressWarnings({"rawtypes","unchecked"})
  Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
  table = newTab;
  return newTab;
}

该方法首先把table及其长度赋值给oldTab和oldCap；threshold是阈值的意思，此时为0，所以前两个if先不管，最后else里newCap的值为默认初始化容量16；往下创建了一个newCap大小的数组并将其赋给了table，刚创建的HashMap对象就在这里获得了初始容量。然后再回到putVal方法，第二个if就是根据哈希码得到的tab中的一个位置是否为空，为空便直接添加元素，此时数组中无元素所以直接添加。至此HashMap对象就完成了第一个元素的添加。当添加的元素超过16*0.75=12时，就会进行扩容：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict){
  if (++size > threshold)
    resize();
}

扩容的代码如下（部分）：

final Node<K,V>[] resize() {
  int oldCap = (oldTab == null) ? 0 : oldTab.length;
  int newCap;
  if (oldCap > 0) {
    if (oldCap >= MAXIMUM_CAPACITY) {//略}
      else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
               oldCap >= DEFAULT_INITIAL_CAPACITY)
        }
  }

核心部分是else if里的移位操作，也就是说每次扩容都是原来大小的两倍。

• 注：额外说明的一点是在JDK1.8以前链表是头插入，JDK1.8以后链表是尾插入。

注意点：当new Hashmap<>()时，可以利用有参构造函数传入cap指定哈希表的初始长度。最终生成的初始长度将是>=cap的2ⁿ的第一个数。