第9讲 | 对比Hashtable、HashMap、TreeMap有什么不同？

典型回答

Map 是广义 Java 集合框架中的另外一部分，是以键值对的形式存储和操作数据的容器类型。

Hashtable：早期 Java 类库提供的一个哈希表实现，线程安全，不支持 null 键和值，由于同步导致的性能开销，所以已经很少被推荐使用。

HashMap： 是应用更加广泛的哈希表实现，行为上大致上与Hashtable一致，线程不安全，支持null键和值，HashMap 进行 put 或者 get 操作，可以达到常数时间的性能。

TreeMap:基于红黑树的一种提供顺序访问的 Map,它的 get、put、remove 之类操作都是O（log(n)）的时间复杂度，具体顺序可以由指定的 Comparator 来决定，或者根据键的自然顺序来判断。

HashMap 明确声明不是线程安全的数据结构，在并发环境可能出现无限循环占用 CPU、size 不准确等诡异问题。

Map 整体结构

image.png

HashMap 的性能表现非常依赖于哈希码的有效性，请务必掌握 hashCode 和 equals 的一些基本约定：

• equals 相等，hashCode 一定要相等。
• 重写了 hashCode 也要重写 equals。
• hashCode 需要保持一致性，状态改变返回的哈希值仍然要一致。
• equals 的对称、反射、传递等特性。

LinkedHashMap 和 TreeMap都可以保证某种顺序，但两者有这些差别：

• LinkedHashMap 通常提供的是遍历顺序符合插入顺序，它的实现是通过为条目（键值对）维护一个双向链表。所谓的 put、get、compute 等，都算作“访问”。

可以利用 LinkedHashMap实现LRU：

import java.util.LinkedHashMap;
import java.util.Map;  
public class LinkedHashMapSample {
    public static void main(String[] args) {
        LinkedHashMap accessOrderedMap = new LinkedHashMap(16, 0.75F, true){
            @Override
            protected boolean removeEldestEntry(Map.Entry eldest) { // 实现自定义删除策略，否则行为就和普遍 Map 没有区别
                return size() > 3;
            }
        };
        accessOrderedMap.put("Project1", "Valhalla");
        accessOrderedMap.put("Project2", "Panama");
        accessOrderedMap.put("Project3", "Loom");
        accessOrderedMap.forEach( (k,v) -> {
            System.out.println(k +":" + v);
        });
        // 模拟访问
        accessOrderedMap.get("Project2");
        accessOrderedMap.get("Project2");
        accessOrderedMap.get("Project3");
        System.out.println("Iterate over should be not affected:");
        accessOrderedMap.forEach( (k,v) -> {
            System.out.println(k +":" + v);
        });
        // 触发删除
        accessOrderedMap.put("Project4", "Mission Control");
        System.out.println("Oldest entry should be removed:");
        accessOrderedMap.forEach( (k,v) -> {// 遍历顺序不变
            System.out.println(k +":" + v);
        });
    }
}

• 对于 TreeMap，它的整体顺序是由键的顺序关系决定的，通过 Comparator 或 Comparable（自然顺序）来决定。跟优先队列PriorityQueue，都是依赖于同一种排序机制（二叉堆）。

• 类似 hashCode 和 equals 的约定，compareTo 的返回值需要和 equals 一致。

HashMap 源码分析

HashMap 内部的结构，它可以看作是数组（Node[] table）和链表结合组成的复合结构，数组被分为一个个桶（bucket），通过哈希值决定了键键值对在这个数组的寻址；哈希值相同的键值对，则以链表形式存储,如果链表大小超过阈值（TREEIFY_THRESHOLD, 8),链表就会被改造为树形结构。

image.png

HashMap初始化采用lazy-load,在首次使用时被初始化（拷贝构造函数除外).

put方法实现：

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

final V putVal(int hash, K key, V value, boolean onlyIfAbent,
               boolean evit) {
    Node[] tab; Node p; int , i;
    if ((tab = table) == null || (n = tab.length) = 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == ull)
        tab[i] = newNode(hash, key, value, nll);
    else {
        // ...
        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for first 
           treeifyBin(tab, hash);
        //  ... 
     }
}

• 如果table未初始化，resize 方法会负责初始化它，resize 方法兼顾两个职责，创建初始存储表格，或者在容量不足时进行扩容。在放置新的键值对的过程中，如果发生下面条件，就会发生扩容。

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

• 具体键值对在哈希表中的位置取决于下面的位运算

i = (n - 1) & hash

• hash值取决于hash方法，需要将高位数据移位到低位进行以后运算。**因为有些数据计算出的哈希值差异主要在高位，而HashMap里的哈希寻址是忽略容量以上的高位的，那么这种处理就可以有效避免类似情况下的哈希碰撞。

static final int hash(Object key) {
  int h;
  return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); 
}

resize() 源码分析

final Node[] resize() {
        Node[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
       // 老数组扩容,扩展一倍
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        // 数组带容量初始化,threadhold=初始容量
        // initial capacity was placed in threshold
        else if (oldThr > 0) 
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            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[] newTab = (Node[])new Node[newCap];
        table = newTab;
        // 把旧数组的数据迁移到新数组
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node 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)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node loHead = null, loTail = null;
                        Node hiHead = null, hiTail = null;
                        Node 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;
    }

容量、负载因子和树化

容量和负载系数决定了可用的桶的数量，空桶太多会浪费空间，如果使用的太满则会严重影响操作的性能。极端情况下，假设只有一个桶，那么它就退化成了链表，完全不能提供所谓常数时间存取。

预先设置的容量（HashMap(int initialCapacity)）需要满足，大于“预估元素数量 / 负载因子”，同时它是 2 的幂数

对于负载因子：

• 如果没有特别需求，不要轻易进行更改，因为 JDK 自身的默认负载因子是非常符合通用场景的需求的。
• 如果确实需要调整，建议不要设置超过 0.75 的数值，因为会增加哈希冲突，降低 HashMap 的性能。
• 如果使用太小的负载因子，预设容量值也进行调整，否则可能会导致更加频繁的扩容，增加无谓的开销，本身访问性能也会受影响。

树化条件

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
...
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
...
}

final void treeifyBin(Node[] tab, int hash) {
    int n, index; Node e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        // 树化改造逻辑
    }
}

当 bin 的数量大于 TREEIFY_THRESHOLD 时：

• 如果容量小于 MIN_TREEIFY_CAPACITY，只会简单的扩容bin
• 如果容量大于 MIN_TREEIFY_CAPACITY ，则进行树化

树化是为了避免哈希冲突退化成链表，影响存取性能。

构造哈希冲突的数据并不是非常复杂的事情，恶意代码就可以利用这些数据大量与服务器端交互，导致服务器端 CPU 大量占用，构成了哈希碰撞拒绝服务攻击。