JDK集合源码之HashMap解析(下)-阿里云开发者社区

开发者社区> 兴趣使然的草帽路飞> 正文

JDK集合源码之HashMap解析(下)

简介: 由于上篇文章JDK集合源码之HashMap解析(上)篇幅较长,为阅读方便,分成两篇博客来分析HashMap!
+关注继续查看

特别说明:由于HashMap底层的红黑树结构比较复杂,因此涉及红黑树相关的操作,我单独写博客为大家分享,文章最后会加上红黑树文章链接!


5.HashMap的成员方法

5.1 put(K key, V value)方法

put方法是比较复杂的,实现步骤大致如下:


先通过 hash 值计算出 key 映射到哪个桶;


如果桶上没有碰撞冲突,则直接插入;


如果出现碰撞冲突了,则需要处理冲突:


a 如果该桶使用红黑树处理冲突,则调用红黑树的方法插入数据;


b 否则采用传统的链式方法插入。如果链的长度达到临界值,则把链转变为红黑树;


如果桶中存在重复的键,则为该键替换新值 value;


如果 size 大于阈值 threshold,则进行扩容;


具体的方法如下:

public V put(K key, V value) {
    // 调用hash(key)计算出key的hash值
    return putVal(hash(key), key, value, false, true);
}


说明:


HashMap 只提供了 put 用于添加元素,putVal 方法只是给 put 方法调用的一个方法,并没有提供给用户使用。 所以我们重点看 putVal 方法。

我们可以看到在 putVal 方法中 key 在这里执行了一下 hash 方法,来看一下 hash 方法是如何实现的。

static final int hash(Object key) {
    int h;
    // 如果key为null,则hash值为0,
    // 否则调用key的hashCode()方法计算出key的哈希值然后赋值给h,
    // 后与h无符号右移16位后的二进制进行按位异或得到最后的hash值,
    // 这样做是为了使计算出的hash更分散
    // 为什么要更分散呢?因为越分散,某个桶的链表长度就越短,之后生成的红黑树越少,效率越高
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

从上面可以得知 HashMap 是支持 key 为空的,而 HashTable 是直接用 Key 来获取hashCode 所以 key 为空会抛异常。


解读上述 hash 方法:


我们先研究下 key 的哈希值是如何计算出来的。key 的哈希值是通过上述方法计算出来的。


这个哈希方法首先计算出 key 的 hashCode 赋值给 h,然后与 h 无符号右移 16 位后的二进制进行按位异或得到最后的 hash 值。


在 putVal 函数中使用到了上述 hash 函数计算的哈希值:

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    ...
    if ((p = tab[i = (n - 1) & hash]) == null) // 这里的n表示数组长度16 ,公式
    // (length - 1) & hash = 桶位下标 当数组长度为2的n次幂数时,
    // 该公式相当于:hash % length 哈希值对数组长度取余
    // 例如:hash % 32 = hash & (32-1)
    ...
}

计算过程如下所示:


说明:


key.hashCode();返回散列值也就是 hashcode,假设随便生成的一个值。

n 表示数组初始化的长度是 16。

&(按位与运算):运算规则:相同的二进制数位上,都是 1 的时候,结果为 1,否则为0。

^(按位异或运算):运算规则:相同的二进制数位上,数字相同,结果为 0,不同为 1。


image.png

image.png

后获得0101==> 下标为5的捅。


简单来说就是:


高 16bit 不变,低 16bit 和高 16bit 做了一个异或(得到的 hashCode 转化为 32 位二进制,前 16 位和后 16 位低 16bit 和高 16bit 做了一个异或)。


问题:为什么要这样操作呢?


如果当 n 即数组长度很小,假设是 16 的话,那么 n - 1 即为 1111 ,这样的值和 hashCode 直接做按位与操作,实际上只使用了哈希值的后 4 位。如果当哈希值的高位变化很大,低位变化很小,这样就很容易造成哈希冲突了,所以这里把高低位都利用起来,从而解决了这个问题。


image.png

image.png

下面,我们来看看 putVal 方法,看看它到底做了什么。


主要参数:


hash:key 的 hash 值

key:原始 key

value:要存放的值

onlyIfAbsent:如果 true 代表不更改现有的值

evict:如果为false表示 table 为创建状态

putVal 方法源代码如下所示:

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

static final int hash(Object key) {
    int h;// 如果key是null 则hash值为0,否则调用key的hashCode()方法,并让高16位参与整个hash异或,如果数组长度比较小的情况下,让高16位也参与寻址,
    // 寻址公式:(length - 1) & hash 
    // 这样可以使计算出的结果更分散,不容易产生哈希冲突
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

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)transient Node<K,V>[] table; 表示存储Map集合中元素的数组。
        2)(tab = table) == null 表示将空的table赋值给tab,然后判断tab是否等于null,第一次肯定是null。
        3)(n = tab.length) == 0 表示将数组的长度0赋值给n,然后判断n是否等于0,n等于0,由于if判断使用双或,满足一个即可,则执行代码 n = (tab = resize()).length; 进行数组初始化,并将初始化好的数组长度赋值给n。
        4)执行完n = (tab = resize()).length,数组tab每个空间都是null。
    */
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    /*
        1)i = (n - 1) & hash 表示计算数组的索引赋值给i,即确定元素存放在哪个桶中。
        2)p = tab[i = (n - 1) & hash]表示获取计算出的位置的数据赋值给结点p。
        3) (p = tab[i = (n - 1) & hash]) == null 判断结点位置是否等于null,如果为null,则执行代码:tab[i] = newNode(hash, key, value, null);根据键值对创建新的结点放入该位置的桶中。
        小结:如果当前桶没有哈希碰撞冲突,则直接把键值对插入空间位置。
    */ 
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 创建一个新的结点存入到桶中
        tab[i] = newNode(hash, key, value, null);
    else {
         // 执行else说明tab[i]不等于null,表示这个位置已经有值了
        Node<K,V> e; K k;
        /*
            比较桶中第一个元素(数组中的结点)的hash值和key是否相等
            1)p.hash == hash :p.hash表示原来存在数据的hash值  hash表示后添加数据的hash值 比较两个hash值是否相等。
                 说明:p表示tab[i],即 newNode(hash, key, value, null)方法返回的Node对象。
                    Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
                        return new Node<>(hash, key, value, next);
                    }
                    而在Node类中具有成员变量hash用来记录着之前数据的hash值的。
             2)(k = p.key) == key :p.key获取原来数据的key赋值给k  key 表示后添加数据的key比较两个key的地址值是否相等。
             3)key != null && key.equals(k):能够执行到这里说明两个key的地址值不相等,那么先判断后添加的key是否等于null,如果不等于null再调用equals方法判断两个key的内容是否相等。
        */
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                /*
                    说明:两个元素哈希值相等,并且key的值也相等,
                    将旧的元素整体对象赋值给e,用e来记录
                */ 
                e = p;
        // hash值不相等或者key不相等;判断p是否为红黑树结点
        else if (p instanceof TreeNode)
            // 放入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 说明是链表结点
        else {
            /*
                1)如果是链表的话需要遍历到最后结点然后插入
                2)采用循环遍历的方式,判断链表中是否有重复的key
            */
            for (int binCount = 0; ; ++binCount) {
                /*
                    1)e = p.next 获取p的下一个元素赋值给e。
                    2)(e = p.next) == null 判断p.next是否等于null,等于null,说明p没有下一个元素,那么此时到达了链表的尾部,还没有找到重复的key,则说明HashMap没有包含该键,将该键值对插入链表中。
                */
                if ((e = p.next) == null) {
                    /*
                        1)创建一个新的结点插入到尾部
                         p.next = newNode(hash, key, value, null);
                         Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
                                return new Node<>(hash, key, value, next);
                         }
                         注意第四个参数next是null,因为当前元素插入到链表末尾了,那么下一个结点肯定是null。
                         2)这种添加方式也满足链表数据结构的特点,每次向后添加新的元素。
                    */
                    p.next = newNode(hash, key, value, null);
                    /*
                        1)结点添加完成之后判断此时结点个数是否大于TREEIFY_THRESHOLD临界值8,如果大于则将链表转换为红黑树。
                        2)int binCount = 0 :表示for循环的初始化值。从0开始计数。记录着遍历结点的个数。值是0表示第一个结点,1表示第二个结点。。。。7表示第八个结点,加上数组中的的一个元素,元素个数是9。
                        TREEIFY_THRESHOLD - 1 --》8 - 1 ---》7
                        如果binCount的值是7(加上数组中的的一个元素,元素个数是9)
                        TREEIFY_THRESHOLD - 1也是7,此时转换红黑树。
                    */
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        // 转换为红黑树
                        treeifyBin(tab, hash);
                    // 跳出循环
                    break;
                }
                 
                /*
                    执行到这里说明e = p.next 不是null,不是最后一个元素。继续判断链表中结点的key值与插入的元素的key值是否相等。
                */
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等,跳出循环
                    /*
                        要添加的元素和链表中的存在的元素的key相等了,则跳出for循环。不用再继续比较了
                        直接执行下面的if语句去替换去 if (e != null) 
                    */
                    break;
                /*
                    说明新添加的元素和当前结点不相等,继续查找下一个结点。
                    用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表
                */
                p = e;
            }
        }
        /*
            表示在桶中找到key值、hash值与插入元素相等的结点
            也就是说通过上面的操作找到了重复的键,所以这里就是把该键的值变为新的值,并返回旧值
            这里完成了put方法的修改功能
        */
        if (e != null) { 
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                // 用新值替换旧值
                // e.value 表示旧值  value表示新值 
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 修改记录次数
    ++modCount;
    // 判断实际大小是否大于threshold阈值,如果超过则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}


(1)计算key的hash值;


(2)如果桶(数组)数量为0,则初始化桶;


(3)如果key所在的桶没有元素,则直接插入;


(4)如果key所在的桶中的第一个元素的key与待插入的key相同,说明找到了元素,转后续流程(9)处理;


(5)如果第一个元素是树节点,则调用树节点的putTreeVal()寻找元素或插入树节点;


(6)如果不是以上三种情况,则遍历桶对应的链表查找key是否存在于链表中;


(7)如果找到了对应key的元素,则转后续流程(9)处理;


(8)如果没找到对应key的元素,则在链表最后插入一个新节点并判断是否需要树化;


(9)如果找到了对应key的元素,则判断是否需要替换旧值,并直接返回旧值;


(10)如果插入了元素,则数量加1并判断是否需要扩容;


5.2 扩容方法 resize()

扩容机制:


什么时候才需要扩容?


当 HashMap 中的元素个数超过数组大小(数组长度)*loadFactor(负载因子)时,就会进行数组扩容,loadFactor 的默认值是 0.75。


HashMap 的扩容是什么?


进行扩容,会伴随着一次重新 hash 分配,并且会遍历 hash 表中所有的元素,是非常耗时的。在编写程序中,要尽量避免 resize。


HashMap 在进行扩容时,使用的 rehash 方式非常巧妙,因为每次扩容都是翻倍,与原来计算的 (n - 1) & hash 的结果相比,只是多了一个 bit 位,所以结点要么就在原来的位置,要么就被分配到 “原位置 + 旧容量” 这个位置。


例如我们从 16 扩展为 32 时,具体的变化如下所示:


image.png

image.png

因此元素在重新计算 hash 之后,因为 n 变为 2 倍,那么 n - 1 的标记范围在高位多 1bit(红色),因此新的 index 就会发生这样的变化。

image.png

说明:


5 是假设计算出来的原来的索引。这样就验证了上述所描述的:扩容之后所以结点要么就在原来的位置,要么就被分配到 “原位置 + 旧容量” 这个位置。


因此,我们在扩充 HashMap 的时候,不需要重新计算 hash,只需要看看原来的 hash 值新增的那个 bit 是 1 还是 0 就可以了,是 0 的话索引没变,是 1 的话索引变成 “原位置 + 旧容量” 。可以看看下图为 16 扩充为 32 的 resize 示意图:


image.png

image.png

正是因为这样巧妙的 rehash 方式,既省去了重新计算 hash 值的时间,而且同时,由于新增的 1bit 是 0 还是 1 可以认为是随机的,在 resize 的过程中保证了 rehash 之后每个桶上的结点数一定小于等于原来桶上的结点数,保证了 rehash 之后不会出现更严重的 hash 冲突,均匀的把之前的冲突的结点分散到新的桶中了。


源码 resize 方法的解读


下面是代码的具体实现:

正是因为这样巧妙的 rehash 方式,既省去了重新计算 hash 值的时间,而且同时,由于新增的 1bit 是 0 还是 1 可以认为是随机的,在 resize 的过程中保证了 rehash 之后每个桶上的结点数一定小于等于原来桶上的结点数,保证了 rehash 之后不会出现更严重的 hash 冲突,均匀的把之前的冲突的结点分散到新的桶中了。

源码 resize 方法的解读

下面是代码的具体实现:
————————————————
版权声明:本文为CSDN博主「兴趣使然的草帽路飞」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/weixin_43591980/article/details/109496637

(1)如果使用是默认构造方法,则第一次插入元素时初始化为默认值,容量为16,扩容门槛为12;


(2)如果使用的是非默认构造方法,则第一次插入元素时初始化容量等于扩容门槛,扩容门槛在构造方法里等于传入容量向上最近的2的n次方;


(3)如果旧容量大于0,则新容量等于旧容量的2倍,但不超过最大容量2的30次方,新扩容门槛为旧扩容门槛的2倍;


(4)创建一个新容量的桶;


(5)搬移元素,原链表分化成两个链表,低位链表存储在原来桶的位置,高位链表搬移到原来桶的位置加旧容量的位置;


5.3 删除方法 remove()

删除方法就是首先先找到元素的位置,如果是链表就遍历链表找到元素之后删除。如果是用红黑树就遍历树然后找到之后做删除,树小于 6 的时候要转链表。


删除 remove() 方法:

// remove方法的具体实现在removeNode方法中,所以我们重点看下removeNode方法
// 根据key删除
public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
// 根据key,value 删除
@Override
public boolean remove(Object key, Object value) {
    return removeNode(hash(key), key, value, true, true) != null;
}

removeNode() 方法

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    // 参数:
    // matchValue 当根据 key和value 删除的时候该参数为true
    // movable 可以先不用考虑这个参数 
    
    // tab:引用当前haashMap中的散列表
    // p:当前node元素
    // n:当前散列表数组长度
    // index:表示寻址结果
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    // 根据hash找到位置 
    // 如果当前key映射到的桶不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        // 进入这个if判断内部,说明桶位是有数据的,需要进行查询操作,并且执行删除
        // node:通过查找得到的要删除的元素
        // e:表示当前node的下一个元素
        // k,v 键 值
        Node<K,V> node = null, e; K k; V v;
        
        // 第一种情况:当前桶位中的元素 即为我们要删除的元素
        // 如果桶上的结点就是要找的key,则将node指向该结点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        // 如果桶位中的头一个元素不是我们要找的元素,且桶位中的e = p.next不为null
        // 说明该桶位中的节点存在下一个节点
        else if ((e = p.next) != null) {
            // 说明:当前桶位,要么是 链表,要么是 红黑树
            
            // 第二种情况:判断桶位中是否已经形成了红黑树
            if (p instanceof TreeNode)
                // 说明是以红黑树来处理的冲突,则获取红黑树要删除的结点
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            // 第三种情况:桶位中已经形成链表
            else {
                // 判断是否以链表方式处理hash冲突
                // 是的话则通过遍历链表来寻找要删除的结点
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 比较找到的key的value和要删除的是否匹配
        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的下一个元素设置为 要删除元素的 下一个元素
                p.next = node.next;
            // 记录修改次数
            ++modCount;
            // 变动的数量
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}


5.4 查找元素方法 get()

查找方法,通过元素的 key 找到 value。

代码如下:

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}


get 方法主要调用的是 getNode 方法,代码如下:

final Node<K,V> getNode(int hash, Object key) {
    // tab:引用当前hashMap的散列表
    // first:桶位中的头元素
    // e:临时node元素
    // n:table数组的长度
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 如果哈希表不为空,并且key对应的桶不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        /* 
            判断数组元素是否相等
            根据索引的位置检查第一个元素
            注意:总是检查第一个元素
        */
        // 第一种情况:定位出来的桶位元素 就是我们要get的数据
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 桶位第一个元素不是我们要找的目标元素,且first.next不为null
        // 说明当前桶位不止一个元素,可能是链表,也可能是红黑树
        if ((e = first.next) != null) {
            // 第二种情况:桶位已经升级成了红黑树
            // 判断是否是红黑树,是的话调用红黑树中的getTreeNode方法获取结点
            if (first instanceof TreeNode)
                // 调用与树相关的方法得到目标元素
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 第三种情况:桶位已经形成链表
            do {
                // 不是红黑树的话,那就是链表结构了
                // 通过循环的方法判断链表中是否存在该key
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    // 如果没找到返回null
    return null;
}


小结:


get 方法实现的步骤:


a. 通过 hash 值获取该 key 映射到的桶


b. 桶上的 key 就是要查找的 key,则直接找到并返回


c. 桶上的 key 不是要找的 key,则查看后续的结点:


如果后续结点是红黑树结点,通过调用红黑树的方法根据 key 获取 value


如果后续结点是链表结点,则通过循环遍历链表根据 key 获取 value


6. 遍历HashMap的几种方式

分别遍历 Key 和 Values

for (String key : map.keySet()) {
    System.out.println(key);
}
for (Object vlaue : map.values() {
    System.out.println(value);
}


使用 Iterator 迭代器迭代

Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Object> mapEntry = iterator.next();
    System.out.println(mapEntry.getKey() + "---" + mapEntry.getValue());
}


通过 get 方式(不建议使用)

Set<String> keySet = map.keySet();
for (String str : keySet) {
    System.out.println(str + "---" + map.get(str));
}

说明

根据阿里开发手册,不建议使用这种方式,因为迭代两次。keySet 获取 Iterator一次,还有通过 get 又迭代一次,降低性能。

  1. jdk8 以后使用 Map 接口中的默认方法:
default void forEach(BiConsumer<? super K,? super V> action) 
// BiConsumer接口中的方法:
    void accept(T t, U u) 对给定的参数执行此操作。  
        参数 
            t - 第一个输入参数 
            u - 第二个输入参数 

遍历代码:

HashMap<String,String> map = new HashMap();
map.put("001", "zhangsan");
map.put("002", "lisi");
map.forEach((key, value) -> {
    System.out.println(key + "---" + value);
});


7.总结

(1)HashMap是一种散列表,采用(数组 + 链表 + 红黑树)的存储结构;


(2)HashMap的默认初始容量为16(1<<4),默认装载因子为0.75f,容量总是2的n次方;


(3)HashMap扩容时每次容量变为原来的两倍;


(4)当桶的数量小于64时不会进行树化,只会扩容;


(5)当桶的数量大于64且单个桶中元素的数量大于8时,进行树化;


(6)当单个桶中元素数量小于6时,进行反树化;


(7)HashMap是非线程安全的容器;


(8)HashMap查找添加元素的时间复杂度都为O(1);


关于HashMap红黑树操作,相关知识,之后很快就会更新…


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
(周期计划-8)常用集合的源码分析:HashMap
写在前面 感兴趣的看官,可以看看我的其他文章:1、从公司代码看Notification2、Java反射实践:从反射中理解class3、从公司项目配置看Gradle 上一篇博客,我们分析了ArrayList的源码实现,ArrayList吊起来观察一番之后,那么下一个被吊起来的肯定就是HashMap了。
811 0
Java 集合源码解析 - ConcurrentHashMap(JDK7)(下)
Java 集合源码解析 - ConcurrentHashMap(JDK7)(下)
8 0
fastjson解析json字符串,key缺少双引号导致下游服务无法解析
背景说明 在使用fastjson 1.2.60版本将对象转化为json字符串时,为处理Map值为null的情况,采用了WRITE_MAP_NULL_FEATURES属性,但该属性解析出来的key中缺少双引号,在key包含特殊字符时,如“-”和“:",下游服务在进行反序列化时出现无法解析的错误,从而出现问题。
3036 0
Java集合源码学习(四)HashMap分析
ArrayList、LinkedList和HashMap的源码是一起看的,横向对比吧,感觉对这三种数据结构的理解加深了很多。 数据结构中有数组和链表来实现对数据的存储,这两者有不同的应用场景, 数组的特点是:寻址容易,插入和删除困难;链表的特点是:寻址困难,插入和删除容易; 哈希表的实现结合了这两点,哈希表的实现方式有多种,在HashMap中使用的是链地址法,也就是拉链法。
1501 0
大数据和人工智能的关系,超全解析
大数据拥抱云计算 在PaaS层中一个复杂的通用应用就是大数据平台。大数据是如何一步一步融入云计算的呢? 1数据不大也包含智慧 一开始这个大数据并不大。原来才有多少数据?现在大家都去看电子书,上网看新闻了,在我们80后小时候,信息量没有那么大,也就看看书、看看报,一个星期的报纸加起来才有多少字?如果你不在一个大城市,一个普通的学校的图书馆加起来也没几个书架,是后来随着信息化的到来,信息才会越来越多。
1650 0
SpringMVC源码解析之AsyncHandlerInterceptor异步的处理器拦截器
SpringMVC源码解析之AsyncHandlerInterceptor异步的处理器拦截器
8 0
HashSet及LinkedHashSet源码分析(基于JDK1.6)
Java容器类的用途是“保存对象”,分为两类:Map——存储“键值对”组成的对象;Collection——存储独立元素。Collection又可以分为List和Set两大块。List保持元素的顺序,而Set不能有重复的元素。
718 0
HashMap源码分析(基于JDK1.6)
在Java集合类中最常用的除了ArrayList外,就是HashMap了。本文尽自己所能,尽量详细的解释HashMap的源码。一山还有一山高,有不足之处请之处,定感谢指定并及时修正。     在看HashMap源码之前先复习一下数据结构。
497 0
细读源码之-HashMap
大家开发中用得最多的工具类就是JAVA的集合框架了,今天我们来从源码的角度剖析Map集合的实现之一HashMap。
274 0
+关注
兴趣使然的草帽路飞
我是路飞,一个双非本科出身的Java程序员,22届校招收获阿里、美团、哔哩哔哩意向书,目前是阿里大家庭中的一名全栈开发工程师。我的博客地址(CSDN 10万粉丝博主、博客专家):csp1999.blog.csdn.net
87
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载