深入理解HashMap-优快云博客

本文链接：https://blog.youkuaiyun.com/sandypig/article/details/107794126

1，hashMap概述

基于哈希表的map接口的非同步实现，允许null值和null键，但是不能保证映射的顺序，特别是顺序的恒久性，也就是每次访问获取的顺序可能都是不一样的。

相当于Hashtable，只不过是非同步的

2，数据结构

底层是一个数组

transient Node<K,V>[] table;

数组中的元素又是一个链表，元素为Node<k,v>,是Map.Entry接口的实现，元素中有一个key-value对还有一个指向下一个元素的引用（类似链表操作）

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

在JDK1.8之前，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的节点都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

3，成员变量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16  //数组默认容量（长度）16
static final int MAXIMUM_CAPACITY = 1 << 30;//数组最大容量 2^30
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因子，当数组中的元素个数等于或大于数组容量*加载因子时，数组就要进行扩容，在将对象put进map时会对此进行检查并扩容
static final int TREEIFY_THRESHOLD = 8;//链表转为红黑树的阈值
static final int UNTREEIFY_THRESHOLD = 6;//
static final int MIN_TREEIFY_CAPACITY = 64;//链表的最小容量

transient Node<K,V>[] table;//数组
transient Set<Map.Entry<K,V>> entrySet;//缓存 用于keySet() and values().
transient int size;//数组中的元素个数 即键值对的数量
transient int modCount;//修改次数，用于标记，防止在迭代的过程中被修改
int threshold;//map的阈值，即map中所包含的键值对数量限制
final float loadFactor;//哈希表的加载因子

4，构造函数

一共有四个，

HashMap();//构造一个初始容量为16 负载因子为0.75的map

HashMap(int initialCapaticy) //构造一个初始容量为initialCapaticy 负载因子为0.75的map

HashMap(int initialCapaticy,float loadFactor) //初始容量和负载因子,负载因子越大表示散列的装填程度越高。

核心思想:初始化容量和加载因子

public HashMap(Map<? extends K, ? extends V> m)

日常使用：接收一个map作为参数或者无参数

如何初始化容量threshold？

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

可以看到初始化容量n并不是使用构造函数时传入的initialCapacity值

n>=initialCapacity

比如 initialCapacity=39 调用tableSizeFor()方法

n=38=0000 0000 0000 0000 0000 0000 0010 0110

n|=n>>>1 表示n=n|n>>>1

n=0000 0000 0000 0000 0000 0000 0010 0110

n>>>1=0000 0000 0000 0000 0000 0000 0001 0011

则 n=0000 0000 0000 0000 0000 0000 0011 0111

n>>>2=0000 0000 0000 0000 0000 0000 0000 1101

则 n=0000 0000 0000 0000 0000 0000 0011 1111

n>>>4=0000 0000 0000 0000 0000 0000 0000 0011

则 n=0000 0000 0000 0000 0000 0000 0011 1111

n>>>8=0000 0000 0000 0000 0000 0000 0000 0000

则 n=0000 0000 0000 0000 0000 0000 0011 1111

n>>>16=0000 0000 0000 0000 0000 0000 0000 0000

n=0000 0000 0000 0000 0000 0000 0011 1111

方法中判断n>0并且n小于最大整数所以返回n+1，通过移位运算将所有有效位都变成了1，再进行加1就得到2的幂值

n+1=0000 0000 0000 0000 0000 0000 0100 0000=64

initialCapacity=16时 n=16。

什么时候初始化数组？

在构造函数中并没有进行数组的初始化，在resize()扩容方法中进行初始化

在第一次将对象put到map中的时候会进行扩容。

如何扩容？假如是第一次调用扩容方法

新建一个数组，数组长度就是构造函数中初始化的阈值threshold，默认为16，更新map的阈值threshold=13*0.75=12，并返回该数组，

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //oldTab为null，返回0
        int oldThr = threshold;  //在构造函数中已经初始化了threshod值 假如为默认值16
        int newCap, newThr = 0;  //新数组容量 和 新的阈值 设置为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  oldThr=16
            newCap = oldThr;    //将新数组容量设置为初始化的阈值
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) { //新的阈值=0  新的阈值=新数组容量*加载因子=16*0.75=12
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;//将新阈值赋值给阈值 更新map阈值=16*0.75=12
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //初始化一个新的数组，容量为新容量，即初始化的阈值
        table = newTab;//新数组赋值给数组属性
        。。。。
        return newTab; //返回数组
}

假如不是第一次扩容？当map中所包含的键值对大于map的阈值时，进行扩容

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

在最大容量范围内，新数组长度和新的阈值都为原来的2倍，并将原数组中的元素重新计算下角标移到新数组中来

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //原数组不为null 返回原长度16
        int oldThr = threshold; //原阈值 12
        int newCap, newThr = 0;//新长度 新阈值都为0
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {  //如果原长度大于或等于最大容量，则无需扩容
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && //否则新长度=旧长度*2
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold   新阈值=就阈值*2
        }
        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]; //新建一个新的数组，并赋给map中数组
        table = newTab;

5，操作数据

put操作，通过map的hash方法取到key的hash值，由putVal()来执行真正的设置操作，onlyIfAbsent=false，表示新值会将旧的值覆盖。

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

基本内容：

1，如果数组等于null或者数组的长度=0 则对数组进行初始化 n默认为16

2，找到对应参数hash在数组中的位置i，并取出i上的键值对p

3，如果位置 i 上没有值新建一个键值对放到该位置，put操作就基本完成

4，如果i位置上已经有了一个值

4.1，该位置上键值对p的key是否于参数key相等，则找到需要的元素

4.2，如果p是一个树结构元素，将该参数key和value放入到树结构中去

4.3，以上都不符，说明p是一个链表结构，循环链表，获取p的next对象，

1）如果p的next为null 则直接新建元素，并检查如果链表的长度大于默认链表阈值则需转为树长度

2）如果p有next值，则检查next的key是否于参数key相等，相等话找到所需元素，跳出循环；不等的话继续循环

4.4，替换旧值

5，修改计数器加1，键值对数量加1，判断是否需要扩容，如果需要则进行扩容

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;//map中的数组tab，key对应的元素p,数组的长度n,key在数组中位置i
        if ((tab = table) == null || (n = tab.length) == 0)//如果数组等于null或者数组的长度=0  则对数组进行初始化  n默认为16
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)  //先找到对应hash在数组中的位置i，并取出i上的键值对p，1,如果该位置上没有值，
            tab[i] = newNode(hash, key, value, null);//新建一个键值对放到该位置，put操作就基本完成
        else {//2,如果i位置上已经有了一个值
            HashMap.Node<K,V> e; K k;//e为参数key对应的元素，
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k)))) //判断该位置上键值对的key是否于参数key相等
                e = p; //如果相等 put操作就基本完成
            else if (p instanceof HashMap.TreeNode) //如果p是一个树结构元素
                e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//将该参数key和value放入到树结构中去
            else { //其他情况 链表结构
                for (int binCount = 0; ; ++binCount) {//循环链表
                    if ((e = p.next) == null) { //e赋值为p的下一个 如果p下一个为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))))// 如果p的下一个不为null,也就是e的值，
                        break;//如果hash与参数hash相同，且key也相同 则表示找到对应的key的元素 跳出循环
                    p = e; //循环到p的next
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;  // 已存在元素的值 原值
                if (!onlyIfAbsent || oldValue == null) //如果onlyIfAbsent=false或者原值为null
                    e.value = value;//那么就用新的值覆盖原值
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;//修改计数+1
        if (++size > threshold)//map中键值对数+1 并与map的阈值做比较 是否需要扩容
            resize();//扩容操作
        afterNodeInsertion(evict);
        return null;
    }

取数据，如果key为null则返回null
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

getNode也比较简单，找对应hash值的位置，该位置上的key刚好与参数key相等则直接返回元素，不等则找链表的下一个或是树结构中找

6，HashMap的遍历方法

1）Iterator<Map.Entry<String,String>> iterator=map.entrySet().iterator();

while(iterator.hasNext()){

System.out.println(iterator.next().getValue());

}

2）

for(Map.Entry<String,String> entry:map.entrySet()){

System.out.println(entry.getValue());

}

3）

for(String key:map.keySet()){

System.out.println(map.get(key));

}

7，hashMap排序方法

按键排序

按值排序

8，线程同步

可以使用Collections工具类的如下方法获得一个同步map，或是自己同步控制

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
    return new SynchronizedMap<>(m);
}

hashMap：基本原理