Java（Android）数据结构汇总（四）-- Map（上）

传送门：Java（Android）数据结构汇总 -- 总纲

简介

这篇主要来整理下基于Map接口实现的数据结构类。Map集合主要用来存储键值对。它的相关实现类有java.util包的HashMap、LinkedHashMap、Hashtable、TreeMap、EnumMap、IdentityHashMap、WeakHashMap和android.util包的ArrayMap、SparseArray、SparseIntArray、SparseBooleanArray、SparseLongArray、LongSparseArray等。下面分别一一来讲解。

Java部分

一、HashMap

HashMap应该也是我们java中最常用的存储键值对的数据结构类了。它内部是以数组+链表（从1.8版本开始引入了红黑树）的形式来存放键值对的。

基本原理

HashMap是通过对key的hash值进行转换来定位每个key在内部数组上的位置。数组的每个元素又都是一个链表，这样如果一个位置有多个键值对的时候就可以依次存放在这个链表上。至于为什么每个位置可能会存在多个值，这个请看后面。

看了上面的原理介绍，可能还比较懵。没事，下面将一一具体来介绍。

具体实现

Key的Hash值计算分两步：

• 第一步：正常计算出key的hash值（调用key的hashCode()方法，如果key是null则其hash值是0）；
• 第二步：对得到的hash值进行扰乱，目的是为了让hash值能尽可能的均匀分布。

  我们认为HashMap的数组上每个位置只有一个元素是最理想的，扰乱操作的目的就是为了让hash值能尽可能的均匀分布（原因看后面如何将hash值转换为数组索引的介绍）。

为什么要用key的hash值而不直接用key，这里先不讲，看完下面的源码再说：

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

// 计算key的HashCode
static final int hash(Object key) {
    int h;
    // 首先，如果key是null，则直接返回0（这里也说明HashMap支持null作为key）
    // 如果key不是null，就计算key的hashCode值并存放到h变量中
    // 最后进行扰乱操作，在1.8版本中是h ^ (h >>> 16)，在1.8版本之前还会有更多次的位运算
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node[] tab; Node p; int n, i;

    // 如果数组（table）还没有初始化，则进行数组的初始化操作
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;

    // 重点
    // 这里通过(n - 1) & hash计算将hash值转换成数组上的索引  --> 解释1（具体解释见后面）
    // 这里通过hash值计算出key在数组上位置，这样就可以直接在这个位置上的链表里面去查
    // 找有没有指定的key，而不需要在整个数组上去查找（这样大大减少了查询范围）
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 如果该位置还没有元素，则直接新建一个节点并存放在该位置
        tab[i] = newNode(hash, key, value, null);
    else {
        // 整个else的逻辑就是为了在该链表上查找是否存在相同的key，如果存在则将该节点赋值给e，如果没有找到e就为null

        // Node节点存储的值有key、key的hashcode、value、next（下一个节点的引用）四个数据
        Node e; K k;

        // 判断链表的头节点是否和本次插入的key相同 --> 解释2
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 判断链表是否是红黑树
        else if (p instanceof TreeNode)
            // 在红黑树中查找是否存在相同的key
            e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 遍历链表，查找是否存在相同的key
            for (int binCount = 0; ; ++binCount) {
                // 整个链表都没有相同key，则新建一个node，并添加到链表结尾
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 判断链表的长度是否达到了TREEIFY_THRESHOLD，
                    // 如果达到就将链表转换成红黑树（红黑树查询速度比链表更快）
                    // 红黑树是1.8版本引入的
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }

                // 如果找到了有相同key的节点，则跳出循环
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;

                p = e;
            }
        }

        // 如果e不为空，表示e所指向的节点的key和当前要插入的key相同，此时用新的value替换该节点的value，而不新建node节点
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }

    ++modCount;

    // 如果当前数组的长度超过了设定的阈值，则进行数组扩容
    if (++size > threshold)
        resize();

    afterNodeInsertion(evict);
    return null;
}

解释1：看下面几个问题：

• 问题1：为什么不直接使用key而要使用key的hash值？

  如果直接使用key，那么在查找的时候需要调用key的equals方法去逐个比较，对吧。首先逐个比较效率就不高（万一要查找的节点正好是最后一个，那岂不是要将整个集合都比较一遍？），再加上equals方法本身效率也不高，这样如果直接使用key的话整个HashMap的性能就很差。

  而用hash值可以直接定位到数组上的某个位置，这样只需要在这个位置的链表上进行查找就行了，从而大大缩小了查找范围和比较的次数。

• 问题2：那为什么又不直接用hash值作为数组上的索引？

  怕数组越界对吧。hash值的范围不可控，直接用hash值作为数组索引容易造成数组下标越界。为了解决这个问题，于是想出了使用hash值和当前数组长度进行取模运算，将结果作为数组的索引，即index = hash % length。index只会在0到length - 1之间，这样就不怕数组下标越界了。

• 问题3：那为什么用的是(n - 1) & hash，而不是hash % n呐？

  其实早期版本就是用hash % n，但是为了追求效率，后来就改成了位运算(n - 1) & hash（位运速度比取模运算快）。

• 问题4：为什么(n - 1) & hash和hash % n是等价的？

  这里利用了HashMap的一个特性：HashMap规定其容量必须是2的n次方（最大为2³⁰次方）,那么n肯定就是2^xx次方了，用二进制表示就是1000...00，最前面是1，后面全是0(假设有k个0)，那么n-1就全变成1了111...1111（k-1个1），hash ^ (n - 1)得到的最大值就是n-1，最小值是0。效果和hash % n一样，只是改为位运算了。位运算比取模运算更快。

解释2：注意这里的比较顺序：

p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))

1. 为时还要比较p.hash == hash？

   因为我们前面是通过hash取模来实现数组上的定位的，所以在数组上同一个位置的hash值不一定就相等，比如 25和33两个hash值，他们对8取模结果都是1。所以需要进行hash值的比较。

2. hash值相等了，为什么还要进一步比较key？

   因为两个不同的key计算出的hash值可能相同（也就是hash碰撞），所以为了解决这个问题需要进一步比较key。

3. 为什么要比较k == key，而不直接用equals方法？

   因为HaspMap允许null作为key，所以不能直接调用equals来比较。

从上面的分析我们还能得出三个HashMap的特性：

1. null可以作为HashMap的key和value。因为key是不能重复了，所以也就只允许一个null作为key，但是允许多个value的值是null；
2. HashMap的key是根据其hash值随机分布在数组上的，所以HashMap的记录是无序的；
3. 我们在HashMap的源码中没有看到任何同步相关的代码，所以HashMap不是线程安全的。

二、LinkedHashMap

LinkedHashMap继承至HashMap，在HashMap的基础上新增了一个双向链表来实现了记录的有序化。

大家不要被这个名字迷惑了，是不是也和ArrayList跟LinkedList一样一个是用数组实现的一个是用链表实现的呐？其实不是的，LinkedHashMap的主要功能是实现了内部元素的有序化（上面说了HashMap的元素是无序的）。

LinkedHashMap的有序有两种模式：插入顺序和访问顺序。具体使用哪种顺序模式是在构造方法处指定的。

插入顺序：就是按照插入的时间排序，先插入的数据排在前面，后插入的数据排在后面。
访问顺序：就是按照最近访问进行排序，访问时间越近的数据排在越靠后的位置，访问时间越远的数据越排在靠前的位置（实现方式就是当元素每次被访问后就将其移动到链表结尾）。LruCache就是基于此原理实现的。

来看这几个构造方法：

public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}

public LinkedHashMap() {
    super();
    accessOrder = false;
}

public LinkedHashMap(Map m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

其中，accessOrder用来指定是否使用访问顺序模式，true表示使用访问顺序模式，否则使用插入顺序模式，默认使用插入顺序模式。

具体实现

首先，LinkedHashMap新增了一个LinkedHashMapEntry，它继承至HashMap的Node类，在其中增加了两个自己用于链表维护的变量：

static class LinkedHashMapEntry extends HashMap.Node {
    // 新增了before、after两个字段，LinkedHashMap使用这两个字段来维护自己的双向链表
    LinkedHashMapEntry before, after;
    LinkedHashMapEntry(int hash, K key, V value, Node next) {
        super(hash, key, value, next);
    }
}

然后，LinkedHashMap重写了HashMap的newNode()方法（HashMap每次新增节点都是通过这个方法来创建一个节点）来实现每次新增数据的时候都能将新增的数据添加到自己维护的链表的结尾，从而保证了插入顺序：

Node newNode(int hash, K key, V value, Node e) {
    LinkedHashMapEntry p = new LinkedHashMapEntry(hash, key, value, e);

    // 调用linkNodeLast方法将这个新增的节点p添加到链表末尾
    linkNodeLast(p);

    return p;
}

private void linkNodeLast(LinkedHashMapEntry p) {
    LinkedHashMapEntry last = tail;
    tail = p;
    if (last == null)
        head = p;
    else {
        p.before = last;
        last.after = p;
    }
}

其次，LinkedHashMap重写了HashMap的afterNodeRemoval()方法（HashMap在删除数据的时候会回调该方法）以保证数据的同步：

// 重写HashMap的afterNodeRemoval方法
void afterNodeRemoval(Node e) { // unlink
    LinkedHashMapEntry p = (LinkedHashMapEntry)e, b = p.before, a = p.after;
    p.before = p.after = null;
    if (b == null)
        head = a;
    else
        b.after = a;
    if (a == null)
        tail = b;
    else
        a.before = b;
}

最后，为了维护访问顺序，LinkedHashMap重写了get()、getOrDefault()和afterNodeAccess()三个方法（当HashMap修改了数据时，比如put了一个相同key不同value，会回调afterNodeAccess()方法）。具体代码如下：

// 重写HashMap的get方法
public V get(Object key) {
    Node e;
    if ((e = getNode(hash(key), key)) == null)
        return null;

    // 如果使用的访问顺序模式，则调用afterNodeAccess方法来移动节点到链表末尾
    if (accessOrder)
        afterNodeAccess(e);

    return e.value;
}

// 重写HashMap的getOrDefault方法
public V getOrDefault(Object key, V defaultValue) {
   Node e;
   if ((e = getNode(hash(key), key)) == null)
       return defaultValue;

    // 如果使用的访问顺序模式，则调用afterNodeAccess方法来移动节点到链表末尾
   if (accessOrder)
       afterNodeAccess(e);
   return e.value;
}

// 重写HashMap的afterNodeAccess方法，监听节点的修改
void afterNodeAccess(Node e) { 
    LinkedHashMapEntry last;

    // 如果使用的访问顺序模式且修改的不是最后一条数据，则将被修改的节点移动到链表末尾
    if (accessOrder && (last = tail) != e) {
        LinkedHashMapEntry p = (LinkedHashMapEntry)e, b = p.before, a = p.after;

        // 先从链表中移除该节点
        p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a != null)
            a.before = b;
        else
            last = b;


        // 将该节点重新添加到链表结尾
        if (last == null)
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
        tail = p;

        ++modCount;
    }
}

三、TreeMap

TreeMap内部是使用红黑树来实现的。对红黑树不了解的可以看github上的这篇文章介绍：教你透彻了解红黑树。

它与HashMap的区别如下：

	实现	顺序	性能损耗	键值对	安全	效率
TreeMap	红黑树	key是有序的	插入/删除	键值都不能为null	线程不安全	低
HashMap	哈希散列表	完全无序	基本无	键值都可以为null	线程不安全	高

因为要对key进行排序，所以key必须要实现自然排序和定制排序中的一种。自然排序就是key要继承java.lang.Comparable接口，而定制排序则需要在创建TreeMap对象的时候指定一个实现了java.lang.Comparable接口的对象，源码如下：

public TreeMap() {
    // 如果使用这个构造方法，key就必须要实现Comparable接口
    comparator = null;
}

public TreeMap(Comparator comparator) {
    // 如果使用这个构造方法，则需要指定一个comparator对象，此时key就不需要实现Comparable接口
    this.comparator = comparator;
}

首先还是来看一下它的Entity类：

static final class TreeMapEntry implements Map.Entry {
    // 存放该节点值的变量（key和value）
    K key;
    V value;

    // 左子节点
    TreeMapEntry left;
    // 右子节点
    TreeMapEntry right;
    // 父节点
    TreeMapEntry parent;
    // 该节点颜色
    boolean color = BLACK;
    ...
}

再来看看put方法：

public V put(K key, V value) {
    TreeMapEntry t = root;
    if (t == null) {
        // compare(key, key); // type (and possibly null) check
        // 这里的if-else主要是对key的类型和是否是null值进行检查
        if (comparator != null) {
            if (key == null) {
                comparator.compare(key, key);
            }
        } else {
            if (key == null) {
                throw new NullPointerException("key == null");
            } else if (!(key instanceof Comparable)) {
                throw new ClassCastException(
                        "Cannot cast" + key.getClass().getName() + " to Comparable.");
            }
        }
         
        root = new TreeMapEntry<>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }

    int cmp;
    TreeMapEntry parent;
    // split comparator and comparable paths
    Comparator cpr = comparator;
    if (cpr != null) {
        do {
            parent = t;
            cmp = cpr.compare(key, t.key);
            if (cmp < 0)
               t = t.left;
            else if (cmp > 0)
               t = t.right;
            else
               return t.setValue(value);
        } while (t != null);
    } else {
        if (key == null)
            throw new NullPointerException();
        
        @SuppressWarnings("unchecked")
        Comparable k = (Comparable) key;
        do {
            parent = t;
            cmp = k.compareTo(t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }
        
    TreeMapEntry e = new TreeMapEntry<>(key, value, parent);
    if (cmp < 0)
        parent.left = e;
    else
        parent.right = e;
    fixAfterInsertion(e);
    size++;
    modCount++;
    return null;
}

final int compare(Object k1, Object k2) {
    return comparator==null ? ((Comparable)k1).compareTo((K)k2)
        : comparator.compare((K)k1, (K)k2);
}

因为TreeMap的主要逻辑是红黑树，如果对红黑树不了解的需要先去学习下红黑树。这里因为篇幅原因就不多讲。

四、Hashtable

Hashtable和HashMap类似，不同之处是Hashtable实现了线程同步。目前已经不建议使用Hashtable了，这里就不多讲解了。如果需要线程同步，给的建议是使用java.util.concurrent包下的ConcurrentHashMap类来代替。下面是来自Hashtable的一段类注释：

If a thread-safe implementation is not needed, it is recommended to use {@link HashMap} in place of {@code Hashtable}. If a thread-safe highly-concurrent implementation is desired, then it is recommended to use {@link java.util.concurrent.ConcurrentHashMap} in place of {@code Hashtable}.

五、EnumMap

EnumMap是一个特殊的Map，它的key被限定为只能是枚举型，并使用key的ordinal值作为其内部数组的下标。这样有两个好处：一是不需要再对key进行hash计算；二是因为使用的是ordinal值(每个枚举类里面的枚举常量的ordinal值有序且唯一)，所以每个位置对应唯一一个key，所以也就不再需要链表，直接用一个数组就能实现。因此EnumMap的效率比HashMap更高。

关于ordinal值：每个枚举型常量都有一个ordinal()方法，用于返回该枚举常量的序号（从0开始）。如：

 enum Light {
    RED, GREEN, YELLOW;
 }

则：RED.ordinal()为0， GREEN.ordinal()为1， YELLOW.ordinal()为2。

还是来看下源码：

public V put(K key, V value) {
    // 容错处理：检查key是否是指定的枚举类型
    typeCheck(key);

    // 可以看出，确实是直接使用key的ordinal值作为数组的下标索引。
    int index = key.ordinal();
    Object oldValue = vals[index];
    // EnumMap内部不直接存储null，如果是null则会用maskNull方法将其转换成一个内部特定的对象
    vals[index] = maskNull(value);
    // 为什么不直接存储null，看这里就明白了，如果某个位置的值为null，表示这个位置没有存储值，而不是存储了一个null值
    if (oldValue == null)
        // 如果当前位置以前的值是null，表示这个位置以前没有存储值，则会执行size++，否则就是值的替换，size就不会变
        size++;

    // 检查值如果是内部特定的对象，则用unmaskNull方法将其重新转换成null返回
    return unmaskNull(oldValue);
}

public V get(Object key) {
    return (isValidKey(key) ? unmaskNull(vals[((Enum)key).ordinal()]) : null);
}

可以看出，EnumMap还是非常简单的。相比HashMap来说，它简化了存储逻辑，使得性能进一步得到了提升。缺点是限制了key只能是枚举型，只能使用枚举型。同样，EnumMap也不是线程安全的。

使用场景：在某些使用枚举型作为key的特定场景下用来代替HashMap，性能会得到进一步提升。

六、IdentityHashMap

IdentityHashMap也是一个特殊的Map，它要求两个key严格相等（key1==key2）才算是同一个key。而它的存储结构是数组。key-value在数组上是挨着存储的，比如table[0]=key，table[1]=value。来看它的一段源码就清楚了：

public V put(K key, V value) {
    // 如果key是null，则将其转换成一个内部固定对象NULL_KEY 
    final Object k = maskNull(key);

    retryAfterResize: for (;;) {
        final Object[] tab = table;
        final int len = tab.length;
        // 这里将key映射到数组上的方式和HashMap一样：将key的hash值和数组长度进行取模运算来得出key在数组上的位置
        // 这里有个细微差别就是计算出的值是偶数（0、2、4、...）正好对应数组的奇数位（1、3、5、...），
        // 这样也保证了数组上的存储顺序为：key、value、key、value、...
        int i = hash(k, len);

        // 从i位置开始往后遍历数组，i = nextKeyIndex(i, len)相当于 i += 2
        for (Object item; (item = tab[i]) != null; i = nextKeyIndex(i, len)) {
            // 这里就是IdentityHashMap的主要特性了：只有当两个key1==key2才算是同一个key（即便equals方法相等也不算）
            if (item == k) {
                // 如果该位置和插入的key相等，那么将value存放在下一个位置（i+1）
                @SuppressWarnings("unchecked")
                V oldValue = (V) tab[i + 1];
                tab[i + 1] = value;
                return oldValue;
            }
        }

        final int s = size + 1;
        // Use optimized form of 3 * s.
        // Next capacity is len, 2 * current capacity.
        if (s + (s << 1) > len && resize(len))
            continue retryAfterResize;

        modCount++;
        tab[i] = k;
        tab[i + 1] = value;
        size = s;
        return null;
    }
}

private static int nextKeyIndex(int i, int len) {
    return (i + 2 < len ? i + 2 : 0);
}

/**
 * Value representing null keys inside tables.
 */
static final Object NULL_KEY = new Object();

/**
 * Use NULL_KEY for key if it is null.
 */
private static Object maskNull(Object key) {
    return (key == null ? NULL_KEY : key);
}

七、WeakHashMap

WeakHashMap与java的对象引用体系有关。HashMap是直接持有key-value的强引用，只要HashMap不主动删除这些key-value（且HashMap本身不能被回收时），他们就不会被系统回收。而WeakHashMap则是持有key的一个弱引用，这样就可以被系统主动回收。

Java的对象引用系统有四种：强引用、软引用、弱引用和虚引用。

1. 强引用：就是平时我们直接对对象的引用，比如Object h = new Object()，这里的h就是一个强引用，在h不超出范围的情况下，只要h不被设置为null，这个对象就不会被系统回收；
2. 软引用：使用SoftReference来实现（具体用法这里不做介绍）。在系统执行gc的时候，如果检查到内存不足，则会回收SoftReference持有的对象。如果我们想在持有的对象被回收后做一些额外处理，则可以配合ReferenceQueue一起使用，将SoftReference对象和ReferenceQueue关联后，当SoftReference持有的对象被回收后会将SoftReference对象添加到ReferenceQueue中；
3. 弱引用：使用WeakReference来实现（具体用法这里不做介绍），在系统执行gc的时候，会回收SoftReference持有的对象。注意与软引用的区别，软引用是在内存不足时才被回收，而弱引用则是只要执行gc就会被回收。如果我们想在持有的对象被回收后做一些额外处理，则可以配合ReferenceQueue一起使用，将WeakReference对象和ReferenceQueue关联后，当WeakReference持有的对象呗回收后会将WeakReference对象添加到ReferenceQueue中；
4. 虚引用：使用PhantomReference来实现（具体用法这里不做介绍）。它和软引用以及弱引用不同，它必须配合ReferenceQueue一起使用，它不会主动清除引用，而是在对象将要被回收时会将其添加到队列（软引用和弱引用是在对象被回收之后才添加到队列）。

我们还是来看看它的源码实现，先看它的Entry类：

private static class Entry extends WeakReference