Collections(六)Map和Set上篇

最新推荐文章于 2024-06-21 17:14:47 发布

chuiyi3047

最新推荐文章于 2024-06-21 17:14:47 发布

阅读量109

点赞数

文章标签： java 数据结构与算法

原文链接：https://my.oschina.net/LeBronJames/blog/3101536

版权

Map是一个键值对映射的集合，不允许重复的键，允许null的键或者值，关于Map接口的方法，请参考《Java Collections Framework(一)概览》。

前面提到过，Map和Collection是独立的两个接口，Java平台提供了三种通用实现： HashMap，LinkedHashMap和TreeMap，从名称中不难发现，Java没有采用可变数组为基础的实现，比如ArrayMap，或者单纯以链表为基础的实现，比如LinkedMap，这里有个重要的单词：Hash，即散列。

本文将详细讨论这些Map的实现原理。

基础知识：哈希表

在讨论Map之前，我们先来熟悉一下数据结构中提及到的哈希表。

哈希表是一种以常量平均时间进行插入和查找的技术，哈希表实现通常是一个数组，将不同的关键字映射到数组某个下标的位置，所以需要一个哈希函数来计算数组中的位置，如index = f(key)。

理想情况下，哈希函数尝试将不同的Key关联到一个唯一的数组下标index，但是由于数组大小是一定的，这就有可能导致不同的Key映射到同一个index，这就是哈希碰撞。

哈希函数
哈希表的性能取决于选择一个好的哈希函数。如果映射的Key是一个整数，那么我们可以 f(key) = key % size 来映射到index，但是如果这些整数具有一些特征，比如size如果是10，key的值也正好都是10的倍数，那么显然这个哈希函数就是糟糕的。

如果映射的key不是一个整数，而是字符串或者一个对象呢？Java通过hashcode()方法来计算这些对象的int类型散列码，然后再处理这个散列码，使其成为数组的下标。我们来看看HashMap中计算哈希函数的源码：

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

可以看到，计算散列码的方式是对象的hashCode值与移位后的值异或，默认的hashcode是通过对象存储地址计算而来的，如果类重写了equals方法，没有重写hashcode方法，在计算散列码时，这个类的两个对象是不一致的，我们应该保证 两个对象equals，那么它们的hashcode应该是相同的，两个对象不equals，hashcode没有强制要求，所以如何编写类的hashcode方法就变得有意义了，具体写法《effective Java》里面有过详细描述，许多IDE也可以生成hashcode方法，这里给出String的源码：

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

注意的是，hash是一个类成员，因为String是final的，所以无需每次计算hashcode，使用hash变量来保存第一次的计算结果。

哈希碰撞
当不同的Key映射到同一个数组位置时，我们就需要解决哈希碰撞的问题，算法有开放寻址法(Open addressing)和分离链接法(Separate chaining)等，我们在这里介绍下 分离链接法。

把数组的元素看成链表结构的头部，如果不同的key映射到同一个位置，如果当前位置是空，则使用当前位置保存元素，如果不为空，表示出现了哈希碰撞，就会向这个链表尾部追加元素。

我们在查找元素时，也是通过key映射到数组的下标，然后 遍历这个链表查找key值相同，hash值相同的元素。

HashMap实现原理

HashMap内部正是以一个数组Node<K,V>[] table来维护哈希表的，通过分离链接法解决哈希碰撞，Node结构体描述了每个节点的结构，实现了Map.Entry<K,V>接口:

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

从图我们看到，<k0, Sayi>、<k1, Sayi>、<k2, Sayi>三个元素经过哈希函数计算出现了哈希碰撞(即hash0、hash1、hash2都映射到下标2的位置)形成了一个链表，当我们寻找k2元素时，就会依次遍历k0、k1和k2。

备注：key为null的元素总是会存储在数组的第0个位置，因为它的hash返回值是0，取余后为0。

我们再来看看如果哈希函数不合理会导致最坏的情况是什么样子的？

答案是退化成一个链表，其中k0到k形成了一个单向链表，当我们查询一个元素时，它的时间复杂度是O(n)，而一个性能优异的哈希表的时间复杂度则常量级的。

初始容量和增长策略

HashMap也遵循了转换构造函数的设计，提供了一个无参构造函数和一个以Map为参数的构造函数，HashMap默认内部数组容量是由一个常量定义的，值为16:

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

为了性能，HashMap提供了设置初始容量的构造函数:

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

注意到：DEFAULT_LOAD_FACTOR(默认值是0.75)是个加载因子，它定义了哈希表何时扩容，即如果当前容量是16，则当元素个数超过16*0.75=12时，就会选择扩容。

我们注意到哈希函数要将整型值映射到一个固定大小数组的某个位置，这是个求余运算，在《Java Collections Framework(四)Deque》介绍过，如果数组大小时2的幂次方，可以用位运算代替求余运算提供效率，所以 HashMap的容量也必须是2的幂次方

我们来看看当我们传任意容量的时候，它是怎么将初始值转化为四舍五入的2的幂次方的，这段代码和在Deque章节中讲到的是同一个算法。

/**
 * Returns a power of two size for the given target capacity.
 */
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

我们现在已经知道， 初始容量是16且必须是2的幂次方，当元素超过容量乘以负载因子 时，就会扩容，我们来看看新增元素的代码：

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 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 {
        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)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    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 != 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;
}

我们看到，通过位运算获得数组下标tab[i = (n - 1) & hash]),然后遍历链表，在链表结尾处插入新Node节点，如果遇到key相同的元素，则更改节点值为新值。

计算哈希的方法hash已经在前文讲过，我们直接拉到代码的最后几行：if (++size > threshold) resize();, threshold这个变量就是容量乘以负载因子的值表示阀值的意思，我们进入resize方法，看看具体如何扩容的：

inal Node<K,V>[] resize() {
    Node<K,V>[] 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
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    // 略去了扩容后重新设置元素的代码

其中newCap表示新的容量，newThr表示新的阀值，核扩容代码是这一行：

if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
         oldCap >= DEFAULT_INITIAL_CAPACITY)
    newThr = oldThr << 1; // double threshold

newCap和newThr都是原来的大小乘以2，之后我们便可以新分配数组空间newTab重新设置集合元素了。

红黑树

我们回过头再看看putVal代码中没有提及的地方:

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    treeifyBin(tab, hash);

我们知道，如果哈希表退化成链表之后，访问性能会大大降低，HahsMap对其作了一个优化尝试把O(n)的复杂度降低到O(logN), TREEIFY_THRESHOLD的常量值为8，即当碰撞元素大于8的时候(binCount没有包含第一个节点)，就会尝试使用红黑树来代替链表。

我们接着看treeifyBin的源码：

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

MIN_TREEIFY_CAPACITY的常量值为64，从源码中我们可以得出结论什么时候会使用红黑树代替链表：

当哈希碰撞个数超过8的时候，容量小于64的时候，那么就会扩大容量来降低哈希碰撞；
当哈希碰撞个数超过8的时候，容量大于等于64的时候，就会使用红黑树来代替链表。

如图所示，这个时候节点的数据结构就会从Node变为TreeNode结构体如下,其中TreeNode继承了LinkedHashMap.Entry，而LinkedHashMap.Entry继承了Node结构体：

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // red-black tree links
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;
}

关于红黑树的细节，请参考专业算法书。

HashMap和视图方法：keySet、valueSet、entrySet

HashMap的遍历是通过这三视图转化为Collection进行迭代遍历的，这三个方法都返回了内部类：

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

我们注意到values返回的是Collection，因为值可以重复。

三个内部集合类实现了迭代器KeyIterator、ValueIterator和EntryIterator，它们继承了HashIterator。

abstract class HashIterator {
    Node<K,V> next;        // next entry to return
    Node<K,V> current;     // current entry
    int expectedModCount;  // for fast-fail
    int index;             // current slot

    HashIterator() {
        expectedModCount = modCount;
        Node<K,V>[] t = table;
        current = next = null;
        index = 0;
        if (t != null && size > 0) { // advance to first entry
            do {} while (index < t.length && (next = t[index++]) == null);
        }
    }

    public final boolean hasNext() {
        return next != null;
    }

    final Node<K,V> nextNode() {
        Node<K,V>[] t;
        Node<K,V> e = next;
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        if ((next = (current = e).next) == null && (t = table) != null) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
        return e;
    }
    // 略

HashMap同遵循了fail-fast的设计，核心迭代下一个元素的代码如下，其中赋值和判融为一体，这行代码并不难理解：

if ((next = (current = e).next) == null && (t = table) != null) {
      do {} while (index < t.length && (next = t[index++]) == null);
}

转载于:https://my.oschina.net/LeBronJames/blog/3101536

chuiyi3047

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Collections(六)Map和Set上篇

Map是一个键值对映射的集合，不允许重复的键，允许null的键或者值，关于Map接口的方法，请参考《Java Collections Framework(一)概览》。前面提到过，Map和Collection是独立的两个接口，Java平台提供了三种通用实现： HashMap，LinkedHa...
复制链接

扫一扫