Java高级技术第四章——Java容器类Map之快速的HashMap

前言

前言点击此处查看:
http://blog.csdn.net/wang7807564/article/details/79113195

HashMap

Java的HashMap实现的数据结构是一个哈希表，其解决哈希冲突的方法是拉链法，使用的哈希函数是取模法。与常规的直接取模法不同，HashMap是通过位运算来实现取模的。这部分思想与ArrayDeque的实现原理是类似的。
HashMap的容量都是符合以2为底数的指数函数，也就是说HashMap的容量都是2的n次幂。这样做的好处是，2的n次幂的数减1之后，可以分为两半部分，前半部分的二进制位都为0,后半部分的都为1.例如2的3次幂为8,如果是8位的有符号数则二进制形式是0x0000 1000,减1后得7,其二进制形式是0x0000 0111.
那么，如果将7与任何数字进行二进制与(AND)运算，那么计算后的结果范围一定是0～7之间的，这样将其作为掩码来使用，就起到了取模的效果。
除此之外，HashMap还定义了几个常量:

    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;//负载因子
    static final int TREEIFY_THRESHOLD = 8; //树化临界值
    static final int UNTREEIFY_THRESHOLD = 6; //非树化临界值
    static final int MIN_TREEIFY_CAPACITY = 64; //最小树化容量

常量说明

我们之前提到过，HashMap解决哈希冲突的方法是拉链法，所谓拉链法就是将数组作为若干个桶(bin)，通过哈希函数来将一个K映射到一个与之向对应的桶中，在桶中查找元素，效率就会很高。添加元素时，将元素向桶内追加，追加的方式是用链表来实现的。这样就可以动态增加节点了，而且还解决了存入元素数量增加造成的哈希冲突。
DEFAULT_INITIAL_CAPACITY 定义的是默认桶的数量，前面说过，桶的数量一定是2的n次幂.
MAXIMUM_CAPACITY 是定义存储元素的极限值，但是并不意味着HashMap只能存储这么多元素，HashMap的理论最大存储数量实际上是2^32.这主要是因为这段代码:

    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;//达到极限时,将threshold置为Integer.MAX_VALUE
            return;//当HashMap的容量已经是2的31次方的时候，直接返回，不再继续扩容
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

上述代码是HashMap的自动扩容方法，其中loadFactor即是负载因子，其默认值为上述定义的0.75,意思是当HashMap中实际存储的元素数量达到其最大容量的0.75时，则进行扩容。因为如果容量过小，会经常造成哈希冲突，如果容量过大又很浪费空间，故而找到一个平衡值，即为负载因子。

JDK 8的改进

自从Java SE 8开始，JDK的代码将HashMap的实现进一步改写了，主要改写的内容是：
但是，如果每个桶内链表的元素数量过多，就会使查找效率退化，因为链表查找的时间复杂度是O(n)，而当n比较大的时候，HashMap的查找效率就要受累了，这将丧失HashMap快速查找的特性。
于是，当每个桶中链表元素的数量过多的时候，就会将桶内的链表改为红黑树的数据结构，这个过程称之为链表的树化(treeify).这部分的实现与TreeMap类似，红黑树的时间复杂度是O(logn),当n比较大的时候，查找效率就会得到提升，但是，却牺牲了插入时的效率。
故而，为了权衡利弊，引入了阈值作为判断，也就是TREEIFY_THRESHOLD常量所定义的，当桶中的元素数量达到这个阈值时，将链表进行树化。而当桶内的元素数量小于UNTREEIFY_THRESHOLD时，将红黑树改为链表。

代码实现

拉链法存储数据结构:

//链表的数据结构
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

    //存储结构
    transient Node<K,V>[] table;//每个数组元素作为一个桶

添加元素:

    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;
    }

上面的一些方法被用作回调函数来用，在HashMap中并没有被实现:

    // Callbacks to allow LinkedHashMap post-actions
    void afterNodeAccess(Node<K,V> p) { }
    void afterNodeInsertion(boolean evict) { }
    void afterNodeRemoval(Node<K,V> p) { }

取出元素:

    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 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                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);//在链表中寻找
            }
        }
        return null;
    }

其中，树化后，寻找某个节点的方法是：

        final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
            TreeNode<K,V> p = this;
            do {
                int ph, dir; K pk;
                TreeNode<K,V> pl = p.left, pr = p.right, q;
                if ((ph = p.hash) > h)
                    p = pl;
                else if (ph < h)
                    p = pr;
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
                else if (pl == null)
                    p = pr;
                else if (pr == null)
                    p = pl;
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
                else if ((q = pr.find(h, k, kc)) != null)
                    return q;
                else
                    p = pl;
            } while (p != null);
            return null;
        }

Hashtable

由于HashMap的所有方法都没有加锁，因此是线程不安全的。Hashtable是一种相对原始一点的哈希表数据结构的实现，实现的方法是线程安全的，可以用于少量并发的场景。但是，不需要使用线程安全的场景下，使用HashMap而避免使用Hashtable.
另外，HashMap可以把null作为Key,而Hashtable不可以将null作为Key,否则会抛出NullPointerException异常。
Hashtable在实现的时候并不是像HashMap一样设计得足够精巧，Hashtable是一种对哈希表数据结构的简单实现，使用synchronized关键字修饰了方法，从而实现了线程安全。
其在采用的哈希函数也是取模法，避免哈希冲突的方法同样是拉链法。在设计Hashtable类中桶的数量的时候，不要求其是2的n次幂数值，因此在取模的时候并不是像HashMap一样使用位运算，故而效率同时也会降低很多，其默认的桶数量是11,负载因子同样为0.75.

    @SuppressWarnings("unchecked")
    public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;//直接取模
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;//遍历链表
            }
        }
        return null;
    }

        public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {//Key不能为null
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;//直接取模
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;//替换旧值
                return old;
            }
        }

        addEntry(hash, key, value, index);//添加新值
        return null;
    }

WeakHashMap

WeakHashMap在代码层面实现的是弱引用，除了具有HashMap的特点，还具有弱引用的特点：
当系统将要出现OOM的时候，WeakHashMap中的元素会被垃圾回收器回收掉。
这种特点通常被作为缓存来使用，其在代码层面是这样实现弱引用：

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>

但是，虽然在集合类中存在WeakHashMap,但是却不存在WeakHashSet这样的类，如果想要实现类似的效果，使用下面的方法：

Collections.newSetFromMap(Map<E,Boolean> map);
//该方法可以将任何 Map包装成一个Set.