Java 笔记-集合

最新推荐文章于 2021-08-29 14:34:33 发布

libayi

最新推荐文章于 2021-08-29 14:34:33 发布

阅读量255

点赞数

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： Java HashMap 笔记

本文链接：https://blog.youkuaiyun.com/Vipfgyy/article/details/79701106

Java 专栏收录该内容

1 篇文章

订阅专栏

笔记整理

Tags： HashMap　　

1.Collection
方法：新增、删除、大小、包含、清空、迭代、并交差
类别：Set、List、Map
在集合框架中，所有的集合类型均有默认的方法实现。
此处输入图片的描述

Map：Map集合即是元素对（Key-Value对，即Key与Value的映射）的集合。Map是一个独立的接口，与Collection及其子类并无任何关系。Map的实现主要有HashMap、TreeMap、LinkedHashMap。

HashMap：
HashMap的结构-> HashMap的存储方式-> Hash算法与定位-> HashMap的扩容
从结构来看，HashMap是数组+链表+红黑树实现的(在JDK1.8中)，如下图所示。

在JDK1.8中，数组（Bucket）的元素（Node）实现了Map.Entry接口（hash，key，value，next）, next非空时是指向定位相同的下一个Entry，Node的代码实现如下：

static class Node<K,V> implements Map.Entry<K,V> {
   final int hash;    //用来定位数组索引位置
   final K key;
   V value;
   Node<K,V> next;   //链表的下一个node

   Node(int hash, K key, V value, Node<K,V> next) { ... }
   public final K getKey(){ ... }
   public final V getValue() { ... }
   public final String toString() { ... }
   public final int hashCode() { ... }
   public final V setValue(V newValue) { ... }
   public final boolean equals(Object o) { ... }
}

　　不难看出Node也就是HashMap中的数据存放的实际节点，有HashMap的实际实现可以看出，要保证HashMap的具体性能，Node节点的存储则非常重要。HashMap由数组 + 链表构成，众所周知，根据索引访问数组中的数据的速度比链表快得多。所以，为了尽量保证能分解索引来查询数据，HashMap必须尽量保证数据的均匀分布，且能根据索引查询数据，并且在数据容量改变时，仍然需要保证能尽量使用数组而不是链表。
　　
　　拆开来看，第一条是要能根据索引存取数据（避免了全局变量），第二条是要保证数据的均匀分布（避免了索引链表），第三条是要保证扩容对数据的索引速度不受影响。
　　
　　HashMap根据hash算法，计算出Key的hash值（也即索引）来选择数据存储位置，那么检索时只需要根据key对应的hash值即能准确定位到对应的Node节点的位置。HashMap的Hash算法分为以下三步：取Key的HashCode、高位运算（扰动函数）、取模运算。HashMap的取模运算设计得非常精巧，不仅仅保证了数据的均匀分布，而且也保证了扩容时重新计算hash值的高效性。
　　
　　由于HashMap的容量总是2的幂次方，所以计算Key的存放索引的时候可以采用 hashCode & (lenght - 1) 的方法来求得取模运算的结果。对key的hash流程大致如下图：
　　
HashMap的Hash算法
　　
　　

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//(n - 1) & hash　　 在JDK1.8中，移除了1.7中的indexFor方法，而改为直接使用

　　碰撞：即hash函数计算出来的hashCode相同，则说明两个元素会发生碰撞，发生碰撞时，元素会用链表的形式链接在一起，会影响HashMap的性能。
　　
　　在设计hash函数时，由于当前Bucket的容量为2的n次幂，所以可以使用按位 & 代替取模运算。在保证数据均匀分布上，根据key计算hash值，并将hashCode的高位与低位相与，降低了hash值的发生碰撞的几率（Peter Lawley的一篇专栏文章《An introduction to optimising a hashing strategy》里的一个实验对是否使用扰动函数对发生碰撞的影响。结果显示，当HashMap数组长度为512的时候，在没有扰动函数的情况下，发生了103次碰撞，接近30%。而在使用了扰动函数之后有92次碰撞。碰撞减少了将近10%。）。
　　
　　在调用put方法时，仍然可能发生碰撞，并且发生碰撞的几率并不低。在HashMap中使用分离链表法来解决hash冲突。分离链表法在HashMap中实现流程大致如下：
　　 1. 当获取到插入元素Key的hash值，首先通过hash值判断对应索引位置是否未null，如果为空则是未发生碰撞，直接插入；
　　 2. 当不为null时，若插入元素与hash对应位置元素key相同则直接覆盖原元素的值，并返回原元素的值；
　　 3. 当插入元素key与对应位置元素key不同时，若对应位置为TreeNode，则直接调用红黑树的插入方法；
　　 4. 否则，循环遍历链表，判断链表中是否存在key相同的元素，若key相同则覆盖并退出循环。
　　 5. 若不相同，则插入该元素并判断插入该元素是否达到预设的阈值，即8，若达到，则将链表转化为红黑树。
　　
　　 * 在HashMap实际实现中，值的覆盖是在最后进行的，若存在Key相同的节点，将待插入元素记录在判断结束后进行值的覆盖。插入完毕后，会判断是否需要进行resize。其中afterNodeAccess和afterNodeInsertion是LinkedHashMap中实现的方法，HashMap中为空方法。
　　
　　具体代码实现如下：

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的代码中充分利用了bool表达式的短路特性，最影响性能判断（equals方法）的均放在表达式尾部。
　　
resize：
　　HashMap的默认容量为16，当向HashMap中put数据时，达到预设的阈值时即会发生resize。HashMap的实现中，会将Bucket的容量扩大为两倍，这与hash算法有关，是为了保证容量始终为2的幂次方。
　　HashMap的构造函数初始化的字段如下：

    int threshold;          //最大容量上限
    final float loadFactor; //负载因子，越低所需内存越多，响应越快
    int modCount;           //内部结构发生变化的次数，更新数据不影响次数
    int size;               //当前容量

　　则HashMap扩容的条件为HashMap中元素个数size达到 threshold * loadFactor时，即会进行resize。
　　在进行resize时，需要重新计算元素的位置，javadoc中说：进行resize时，元素要么在原位置，要么在原位置再移动原容量oldCapacity的位置。具体原理如下图：
　　
　　不难看出元素的位置即为原位置 + oldCapacity，也即5 + 16 = 21,所有resize时，节点的第0个数据不移动，其余数据则对应的移动原位置 + oldCapacity。同时，在resize过程中，并不会存在较大开销，只需要进行修改其引用即可，这也是HashMap采用链表/红黑树(红黑树本质也与链表类似)的一个原因，将存在冲突的节点均匀分布到了其他节点，也保证了HashMap扩容后的性能。
　　

参考：HashMap实现原理　