Java集合-HashMap

最新推荐文章于 2024-01-03 17:23:04 发布

_宏亮

最新推荐文章于 2024-01-03 17:23:04 发布

阅读量423

点赞数

分类专栏：集合

本文链接：https://blog.csdn.net/oheg2010/article/details/89301933

版权

集合专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Java集合-HashMap

前言

前言

了解HashMap前，我们先了解几个概念

哈希算法，是一类算法。
哈希表(Hash Table)，是一种数据结构，提供一种快速获取。
哈希函数，是支撑哈希表的一类函数。
Map是映射/地图的意思，在Java中Map表示一种把K映射到V的「数据类型」。
HashMap，是Java中用哈希表实现的一种Map。

哈希算法

Hash算法是摘要算法：它从不同的输入中，通过一定的计算，摘取出来一段输出数据，且这个值可以区分输入数据
哈希算法的使用主要是作加密算法，如有名的MD5算法，然后可以用于实现快速查找，使用其原理实现哈希表，这种结构有利于我们实现数据的快速存和取。

哈希表

什么是哈希表

理想的情况是希望不经过任何比较，一次存取便能得到所查记录，那就必须在记录的存储位置和它的关键字之间建立一个确定的关系ff，使每个关键字和结构中一个唯一的存储位置相对应。因而在查找时，只要根据这个对应关系ff找到给定值KK的像f(K)f(K)。若结构中存在关键字和KK相等的记录，则必定在f(K)f(K)的存储位置上，反之在这个位置上没有记录。由此，不需要比较便可直接取得所查记录。在此，我们称这个对应关系ff为：哈希(Hash)函数，按这个思想建立的映射关系表为：哈希表。
哈希函数特点

灵活：哈希函数是一个映像，因此哈希函数的设定很灵活，只要使得任何关键字由此所得的哈希函数值都落在表长允许的范围之内即可
冲突：对不同的关键字可能得到同一哈希地址，即key1≠key2，而f(key1)=f(key2) ，这种现象称为「冲突(collision)」。

哈希函数详细描述

上面我们已经引出了并解释了哈希函数，即「哈希函数」是支撑「哈希表」的「一类函数」。实际工作中，需要视不同的情况采用不同的Hash函数，通常要考虑的因素有：

Hash函数执行的时间。
关键字的长度。
Hash表的大小。
关键字的分布情况。
记录的查找频率。

有如下一些常用的Hash函数构造方法：

直接寻址法：f(k)=kf(k)=k 或者f(k)=a∗k+bf(k)=a∗k+b
取k 或k 的某个线性函数为Hash地址。
数字分析法：首先分析待存的一组关键字，比如是一个班级学生的出生年月日，我们发现他们的出生年大体相同，那么我们肯定不能用他们的年来作为存储地址，这样出现冲突的几率很大；但是，我们发现月日的具体数字差别很大，如果我们用月日来作为Hash地址，则会明显降低冲突几率。因此，数字分析法就是找出关键字的规律，尽可能用差异数据来构造Hash地址
平方取中法：先求出关键字的平方值，然后按需要取平方值的中间几位作为哈希地址。这是因为：平方后中间几位和关键字中每一位都相关，故不同关键字会以较高的概率产生不同的哈希地址。
特点：由于直接地址法相当于有多少个关键字就必须有多少个相应地址去对应，所以不会产生冲突，也正因为此，所以实际中很少使用这种构造方法。

例：我们把英文字母在字母表中的位置序号作为该英文字母的内部编码。例如K的内部编码为11，E的内部编码为05，Y的内部编码为25，A的内部编码为01, B的内部编码为02。由此组成关键字“KEYA”的内部代码为11052501，同理我们可以得到关键字“KYAB”、“AKEY”、“BKEY”的内部编码。之后对关键字进行平方运算后，取出第7到第9位作为该关键字哈希地址，如下图所

关键字	内部编码	内部编码的平方值	H(k)关键字的哈希地址
KEYA	11050201的	122157778355001	778
KYAB	11250102	126564795010404	795
AKEY	01110525	001233265775625	265
BKEY	02110525	004454315775625	315

特点：较常用。

折叠法：将关键字分割成位数相同的几部分（最后一部分位数可以不同），然后取这几部分的叠加和（去除进位）作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐，然后相加；间界叠加是从一端向另一端沿分割界来回折叠，然后对齐相加。
随机数法：选择一个随机函数，取关键字的随机函数值作为Hash地址，通常用于关键字长度不同的场合。即
f(key)=random(key)
特点：通常，关键字长度不相等时，采用此法构建Hash函数较为合适。
除留取余法：f(k)=kf(k)=k modmod pp ， p<=mp<=m
取关键字被某个不大于Hash表长m 的数p 除后所得的余数为Hash地址。

特点：这是最简单也是最常用的Hash函数构造方法。可以直接取模，也可以在平法法、折叠法之后再取模。

值得注意的是，在使用除留取余法时，对p 的选择很重要，如果p 选的不好会容易产生同义词。由经验得知：p 最好选择不大于表长m 的一个质数、或者不包含小于20的质因数的合数。

处理冲突

如何处理冲突是哈希造表不可缺少的一个方面。现在描述一下处理冲突：

假设哈希表的地址集为 : 0−(n−1)0−(n−1)，那么「冲突」是指 : 由关键字得到的哈希地址为j(0≤j≤n−1)j(0≤j≤n−1)的位置上已存有记录，而「处理冲突」: 就是为该关键字的记录找到另一个「空的哈希地址」。

在处理冲突的过程中可能得到一个地址序列 Hi,i=1,2,…,k(Hi∈[0,n−1])Hi,i=1,2,…,k(Hi∈[0,n−1])。处理时，若得到的另一个哈希地址HiHi 仍然发生冲突，则再求下一个地址H2H2，若H2H2 仍然冲突，再求H3H3，依次类推，直至HkHk 不发生冲突为止，则HkHk 为记录在表中的地址。（注意，此定义不适合链地址法）

冲突处理通常有以下4种方法

1.开放定址法：

Hi=(H(key)+di)modm，i=1,2,…,k(k≤m−1)Hi=(H(key)+di)modm，i=1,2,…,k(k≤m−1)
H(key)H(key) 为哈希函数；mm 为哈希表表长；
didi 为增量序列，有3种取法：

di=1,2,3,…,m−1di=1,2,3,…,m−1，称为线性探测再散列；
di=12,−12,22,−22,32,…,±k2，(k≤m2)di=12,−12,22,−22,32,…,±k2，(k≤m2)，称为二次探测再散列；
di=伪随机数序列di=伪随机数序列，称为伪随机探测再散列；

2.再哈希法：Hi=RHi(key),i=1,2,…,kHi=RHi(key),i=1,2,…,k
RHiRHi 均是不同的哈希函数，即在同义词产生地址冲突时计算另一个哈希函数地址，直到冲突不再发生，这种方法不易产生聚集，但增加了计算时间；

3.链地址法：将所有关键字为同义词的记录存储在同一线性表中。即在Hash 出来的哈希地址中不直接存Key ，而是存储一个Key 的链表，当发生冲突时，将同义的Key 加入链表。

这里写图片描述
4.公共溢出区：可以建立一个公共溢出区，用来存放有冲突的Key。比如设立另一个哈希表，专门用来存放出现冲突的同义词

查找及分析

在哈希表上进行查找的过程和哈希造表的过程基本是一致的，在此不再赘述。
接下来我们来分析一下哈希表的「查找长度」。

平均查找长度
虽然哈希表在关键字与记录的存储位置之间建立了直接映像，但由于“冲突”的存在，使得哈希表的查找过程仍然是一个“给定值和关键字进行比较”的过程。因此，仍需以平均查找长度作为衡量哈希表的查找效率的量度。

（还记得上面我们说的“理想情况下”吗？~~ 现实告诉我们，一般情况下，还是不得不需要“比较”！）

查找过程中，需要“和给定值进行比较的关键字的个数”取决于下列三个因素：

哈希函数的好坏。
处理冲突的方法。
哈希表的装填因子。

装填因子
在一般情况下，我们设计的哈希函数肯定是尽量均匀的，没有提升空间了，所以可以不考虑它对平均查找长度的影响。那么，对于处理冲突方法相同的哈希表，其平均查找长度就依赖于哈希表的装填因子了。其定义如下：

α=表中填入的记录数哈希表的长度α=表中填入的记录数哈希表的长度；装填因子α标志哈希表的装满程度

直观的看：

α越小，发生冲突的可能性就越小。
α越大，代表着表中已填入的元素越多，再填入元素时发生冲突的可能性就越大。那么在查找时，给定值需要比较的关键字的个数就越多。
所以，对于平均查找长度我们的结论如下：

哈希表的「平均查找长度」是装填因子α 的函数，而不是n 的函数。
因此，不管n 多大，我们总是可以选择一个合适的装填因子以便将平均查找长度限定在一个范围内。
（Java 中HashMap 的默认负载因子是0.75）

java中的Map

HashMap是使用Key Value键值对存储数据的常用集合类。在Java集合框架中List和Set都继承于Collection类，但HashMap主要是实现Map接口,Map依赖Collection实现数据循环，下面看下网上整理的结构图
在这里插入图片描述

Map集合框架下的4个实现类:HashMap，HashTable,TreeMap，LinkedHashMap

HashMap基于哈希散列表(hash table)实现,是一种随机的键值对存储形式，并允许一条记录的键为null,多条记录的值为null，属于非线程安全，当需要使用线程安全的Map集合时候，建议使用ConcurrentHashMap,或者使用Collections的SynChronizedMap方法使HashMap具有线程安全的能力。
HashTable产生于JDK1.1,早于HashMap的1.2，HashTable继承于抽象类Dictionary,并且不允许键值为null。HashTable是线程安全，如get方法使用SynChronized描述符以及遍历数据的使用Collections.SynChronizedXXX进行了同步包装，但这样的线程的安全只是单线程的，也就是任何时间都只有一个线程能读写HashTable ,故并不高效，在多线程操作的时候建议使用ConcurrentHashMap，ConcurrentHashMap实现了分段锁，在JDK1.7中默认能有16个线程同时读写数据
TreeMap实现SortedMap接口基于红黑树，能将保保存的数据根据键来排序，默认的排序是按照升序排序，并且键值都不能为null,是非线程安全
LinkedHashMap是HashMap的子类，记录了数据参入的顺序,当使用Iterator循环遍历的时候，将根据插入的顺序得到数据，和hashMap一样，LinkedHashMap非线程安全，允许key和value为空，key重复为空就覆盖

HashMap上帝视角:

HashMap非线程安全,允许一条记录使用空key和多条记录为空value
HashMap使用数组存储数据，d默认数组长度是16，负载因子为0.75
Hash冲突使用链地址法解决，为了解决链表的查询效率，当链表长度大于8的时候转换成红黑树
HashMap 数组长度不够时进行扩容，扩容后数组大小为当前的 2 倍
当不考虑hash冲突的时候，取值的时候时间复杂度为O(1),每一个数组下标对应的链表中取值时候其复杂度就是O(n)；产生冲突后当链表长度大于8时，复杂度为O(logn)

HashMap源码分析

在使用HashMapMap的时候，其实HashMap为我们提供了4个构造函数，用于不同的使用场景。

public HashMap() {
}
public HashMap(int initialCapacity) {
}
public HashMap(int initialCapacity, float loadFactor) {
}
public HashMap(Map<? extends K, ? extends V> m) {
}

上面可以看到有一个默认的无参构造函数和一个传递Map的函数外还有就是传递参数的了，在这里的两个参数子作用就是设置HashMap的初始长度以及负载因子，

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;//链表最大长度为8
int threshold;//最大容量，比如第一次扩容后数组长度为16，能存放数据最大容量为12，当大于12后，开始扩容

那么在数组中又是怎么存储数据，链表又是怎么表示的呢？那么我们就要看看HashMap中的一个内部类Node类，上图中每一个黑点就代表一个Node对象，Node对象主要包含4个属性

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash; // 1 当前节点对象的hash值，用来定位所在位置，
    final K key;    //2 对应HashMap中的 key
    V value;    // 对应HashMap中的 value
    Node<K,V> next; //当前节点所对应的下一个节点，如果没有就为null

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

HashMap的put方法:

在HashMap中有一个变量transient Node<K,V>[] table;第一次put值得时为空，会执行resize()方法，在resize()后，会执行table = newTab;,也就是说table第一次没有值，后面就是当前数组的长度

public V put(K key, V value) {
    //首先会根基key进行计算其hash值
    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;
// 1 判断当前table是否为空，第一次会为空在resize()中就会创建一tablle，下次就不为空
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
// 2 (n - 1) & hash 计算的到一个数组下标i，取出tab[]数组中i 的值p，如果为空，就直接在tab[i]上进行赋值
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
//3 如果当前下标i上已经有值，就可能产生哈希冲突或者是相同元素，
        Node<K,V> e; K k;
//4 如果hash相等，并且key相等或者key.eques相等，则说明是重复元素，直接覆盖
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
//5 如果不是同一元素，产生冲突前判断p节点是否是树结构
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
//6 这里就是说不是树，但是产生了hash冲突，开始要循环遍历链表了
            for (int binCount = 0; ; ++binCount) {
//7 首先判断p的next节点是否有数据
                if ((e = p.next) == null) {
//8 没有数据直接将新数据添加到p的next节点上
                    p.next = newNode(hash, key, value, null);
//9 当链表长度大于8就转成红黑树处理
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
//10 如果可key存在就直接覆盖
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
//11 一直循环到p.next 为空，或者有key存在就跳出循环
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);//这里的方法使用使用多态，如果是LinkedHashMap就会调用其相关代码
            return oldValue;
        }
    }
    ++modCount;
//12 如果超过最大容量threshold就扩容，threshold在初始化的时候是没有赋值的，在第1步resize()扩容的时候进行了赋值
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);//这里的方法使用使用多态，如果是LinkedHashMap就会调用其相关代码
    return null;
}

HashMap的resize()方法

HashMap的第一次resize()是发生在第一次put的时候，在扩容后数组大小为当前的 2 倍。后面会分析其为什么，扩容后的大小都是2的n次方，以及这样扩容带来的好处
第一次扩容后threshold=12；table.size=16;
第二次扩容后threshold=24；table.size=32;

final Node<K,V>[] resize() {
// 1、第一次扩容的时候table是为null的，oldCap就=0；后面oldCap就是table的长度
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 2、获取数组容器最大长度赋值给oldThr，
    int oldThr = threshold;
    int newCap, newThr = 0;
//3、第一次put调用resize()的时候不走  if (oldCap > 0) ，因为这时oldCap==0，直接走第5步
    if (oldCap > 0) {
// 第二次后，oldCap>0,再判断如果oldCap已经大于等于1<<30 ,这个数，则将Integer.MAX_VALUE最大数复制给最大容量
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
//oldCap<<1相当于于oldCap乘以2，oldCap>>1相当于oldCap除以2，并赋值给newCap，第二次的时候就是newCap为32=16*2
//如果扩容后的值oldCap乘以2后小于MAXIMUM_CAPACITY（MAXIMUM_CAPACITY= 1<<30），并且oldCap>=16,那么新的newThr就等于旧的oldThr扩大两倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
                 //这里得到新的newCap和newThr
            newThr = oldThr << 1; // double threshold
    }

// 4、new  map的时候构造方法可以传递参数，会赋值最大容量threshold，上面第2步的时候会使oldThr大于零
    else if (oldThr > 0) // initial capacity was placed in threshold
    //如果刚开始数组大小没有值，最大容量有值，则将最大容量赋值给新的数组长度
        newCap = oldThr;
    else {
 //5、如果new  map构造函数没有传递值，那么第一次扩容就走这个方法，也就是第一次扩容后容器大小为DEFAULT_INITIAL_CAPACITY
 //如果oldCap > 0和oldThr > 0都不成立，则将16设置给newCap做为数组长度
        newCap = DEFAULT_INITIAL_CAPACITY;
// 6、0.75*16=12
        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);
    }
    //7、第一次扩容后table长度为16，最大 threshold=12；
    threshold = newThr;
//创建一个新的长度的数组，开始要扩容了
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
//第一次扩容oldTab为空，后面再扩容就开始重新计算hashCode 
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
//如果下标不为空就走下面的，为空就不管
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
//如果当前下标下面没有next数据，e.hash & (newCap - 1)计算下标，再将数据赋值给当前下标
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
//如果下标下面已经大于8是树结构
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
//进入这里说明next有值但链表长度不大于8
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
//进行do while循环，直到next为空。在最后while中将新的next赋值给e,do中再取e的next
                    do {
                        next = e.next;
                        //如果当e.hash & oldCap运算等于0，位置不做移动
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
//这里上面do while 循环是为了将某一个下标中链表分成两个，比如下标1中有链表 1、2、3、4，最后根据e.hash & oldCap) == 0将链表分离比如得到 1、2和3、4，最后根据判断loTail和hiTail，将分离的链表分别放在原来的下标j和j + oldCap下标上。
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }    
                }
            }
        }
    }
    return newTab;
}

HashMap的remove()

三元运算符判断removeNode()方法返回进行赋值，在调用removeNode()方法前根据key获取返回的hash

  public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        //如果添加过数据table就是有值的
        //首先判断table不为空并且tab长度>0,并且tab[index]下标的值不为空
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            //tab[index]的p.hash相等，key相等，或者key不为空且equals相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //获得了对应的值，可以删除了
                node = p;
            else if ((e = p.next) != null) {//比如上面hash相同key不同，就是冲突了。冲突后，下面判断是否已经是红黑树
                if (p instanceof TreeNode)
                //是树，取出值
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {     
                    do {
                     //不是，还是根据hash和key同时相等，或者key不为空，key的equals相等，取出值
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                        //循环到e.next不为空，找到后跳出
                    } while ((e = e.next) != null);
                }
            }
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                //如果是树
                if (node instanceof TreeNode)
                //走删除树逻辑
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)//不是树，判是否为空
                    tab[index] = node.next;//设置空
                else
                    p.next = node.next;//将关联进行交换
                ++modCount;
                --size;//hashMap的长度减少
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

HashMap的hash()

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

从上面的代码可以看到key的hash值的计算方法。key的hash值高16位不变，低16位与高16位异或作为key的最终hash值。（h >>> 16，表示无符号右移16位，高位补0，任何数跟0异或都是其本身，因此key的hash值高16位不变。）
看图片描述
在这里插入图片描述
为什么要这么干呢？
这个与HashMap中table下标的计算有关。

n = table.length;
index = （n-1） & hash;

因为，table的长度都是2的幂，因此index仅与hash值的低n位有关，hash值的高位都被与操作置为0了。
假设table.length=2^4=16。
看图片描述
在这里插入图片描述
由上图可以看到，只有hash值的低4位参与了运算。
这样做很容易产生碰撞。设计者权衡了speed, utility, and quality，将高16位与低16位异或来减少这种影响。设计者考虑到现在的hashCode分布的已经很不错了，而且当发生较大碰撞时也用树形存储降低了冲突。仅仅异或一下，既减少了系统的开销，也不会造成的因为高位没有参与下标的计算(table长度比较小时)，从而引起的碰撞。
在这里插入图片描述

&：两个数都转为二进制，然后从高位开始比较，如果两个数都为1则为1，否则为0。
^：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。
|：两个数都转为二进制，然后从高位开始比较，两个数只要有一个为1则为1，否则就为0。
~：如果位为0，结果是1，如果位为1，结果是0.
~的优先级最高，其次是<<、>>和>>>，再次是＆，然后是^，优先级最低的是|。

梳理

HashMap厉害之处主要是其优化的hash()方法，以及使用的2的次幂进行容量扩充，解决了扩容后重新分配位置的性能损耗；其次在产生冲突后，当节点长度大于8的时候转成红黑树，优化产生冲突后遍历链表的性能损失。

Java8系列之重新认识HashMap
HashMap 和 ConcurrentHashMap 全解析
 HashMap实现原理及源码分析
 java运算符与（&）、非（~）、或（|）、异或（^）
Java 位运算
 集合系列文章
 哈希表、Java中HashMap
HashMap的hash()

_宏亮

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java集合-HashMap

Java集合-HashMap前言哈希算法哈希表什么是哈希表哈希函数详细描述处理冲突查找及分析java中的MapHashMap上帝视角:HashMap使用HashMap的put方法:MashMap的hash方法和hash桶数组索引位置：HashMap的resize()方法HashMap的长度保持2的次幂好处：前言了解HashMap前，我们先了解几个概念哈希算法，是一类算法。哈希表(Hash...
复制链接

扫一扫