HashMap

已于 2023-12-15 23:13:47 修改
阅读量102 收藏
点赞数
分类专栏： 源码学习 文章标签： java
于 2023-08-12 17:27:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bourne_First/article/details/132251269
版权

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GrZxJTzR-1691832408829)(java_source_imgs\1.png)]

HashMap

  1. key 允许null value 也可以为 Null
  2. HashTable 也是实现了map接口
  3. HashMap 和 HashTable 类似，只是HashTable 时同步的，并且不允许null （that it is unsynchronized and permits nulls）
  4. 不能保证映射的顺序
  5. hashMap 和初始化容量和load factor 相关，如果，hashMap中的元素超过了初始化容量和load factor，就会重新分配，并且容量为以前的两倍
  6. 取模最好的公式: hash % n = hash & (n - 1) -> 但 n 必须是 2 的次幂，看看为啥
  7. hashmap 是数组 + 链表 + 红黑树构成，尽管 hashmap key 和 value 都可以为null，但并不是 node 数组为 null，而是 node 的 key 和 value 属性为 null
  8. containsValue 为啥没关注树结构

tableSizeFor

根据入参，返回大于入参&2的次方（但是不能大于 1<<30）
n |= n >>> 1 表示 n 的后一位变成 1 1000000 | 0100000 = 1100000
n |= n >>> 2; 表示 n 的第3、4位变成1 1100000 | 0011000 = 1111000
n |= n >>> 4; 表示 n 的第5～8位变成 1 1111000 | 0000111 = 1111111
如果 n 小于 0 ，则返回 1，另外需要判断是否大于 1 << 30，
n + 1 就是要保证是 2 的次方

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

getNode


/**
  * Implements Map.get and related methods.
  *
  * @param hash hash for key
  * @param key the key
  * @return the node, or null if none
  */
 final Node<K,V> getNode(int hash, Object key) {
     Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
     // table 不为空 & table.size 不为空 & tab[(n - 1) & hash] != null(链表不为空），执行内容，否则直接返回 null
     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;
 }

containsKey

判断是否包含当前key，应该用 containsKey ，而不是通过 get(key) == null 进行判断，HashTable 可以

/**
* Returns <tt>true</tt> if this map contains a mapping for the
 * specified key.
 *
 * @param   key   The key whose presence in this map is to be tested
 * @return <tt>true</tt> if this map contains a mapping for the specified
 * key.
 */
public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

containsValue

为啥没关注树

/**
 * Returns <tt>true</tt> if this map maps one or more keys to the
 * specified value.
 *
 * @param value value whose presence in this map is to be tested
 * @return <tt>true</tt> if this map maps one or more keys to the
 *         specified value
 */
public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
        for (int i = 0; i < tab.length; ++i) {
            for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;
}

clear

 /**
  * Removes all of the mappings from this map.
  * The map will be empty after this call returns.
  */
 public void clear() {
     Node<K,V>[] tab;
     modCount++;
     if ((tab = table) != null && size > 0) {
         size = 0;
         for (int i = 0; i < tab.length; ++i)
             tab[i] = null;
     }
 }

构造函数

​ putMapEntries 这个函数比较有意思，

		1.  float ft = ((float)s / loadFactor) + 1.0F; ==为啥==
		2.  int s = m.size();        这儿是要获取原先map的元素个数，并不是原先元素的容量。====


/**
     * Constructs a new <tt>HashMap</tt> with the same mappings as the
     * specified <tt>Map</tt>.  The <tt>HashMap</tt> is created with
     * default load factor (0.75) and an initial capacity sufficient to
     * hold the mappings in the specified <tt>Map</tt>.
     *
     * @param   m the map whose mappings are to be placed in this map
     * @throws  NullPointerException if the specified map is null
     */
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
/**
     * Implements Map.putAll and Map constructor.
     *
     * @param m the map
     * @param evict false when initially constructing this map, else
     * true (relayed to method afterNodeInsertion).
     */
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { // pre-size
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            else if (s > threshold)
                resize();
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

红黑二叉树

特性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z8hYEDDM-1691832408830)(java_source_imgs/red_black_tree_features.jpg)]

红黑二叉树旋转小技巧

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2lg4a1II-1691832408831)(java_source_imgs\red_black_1.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MxZhj3zF-1691832408832)(java_source_imgs\red_black_2.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XCGlRccC-1691832408833)(java_source_imgs\red_black_3.png)]

情况 4

当前节点为父结点的右子树，而父结点为祖父节点的左子树（三者不在一条直线上）

解决办法：当前节点、父结点、祖父节点不在一条线上，需要先以父结点进行左转，然后再以祖父节点进行右转，并将父结点变成黑色，而祖父节点变成红色。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rcp79Inn-1691832408835)(java_source_imgs\red_black_4.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-txzuBuCY-1691832408836)(java_source_imgs\red_black_5.png)]

情况5

当前节点为父结点的左子树，父结点为祖父节点的左子树（三者在一条直线上）

解决办法：首先以父结点进行右转，将父结点设置为黑色节点，而将祖父节点设置为红色节点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G5XPDf2F-1691832408837)(java_source_imgs\red_black_6.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T28o7lPR-1691832408838)(java_source_imgs\red_black_7.png)]

情况6

当前节点为父结点的左子树，父结点为祖父节点的右子树（三者不在一条直线上）

解决办法：首先以父结点进行右旋，然后以祖父节点进行左旋，接着将父结点变成黑色，而祖父节点变成红色。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Bm2jxC9-1691832408839)(java_source_imgs/beforechange.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SNQHhCae-1691832408840)(java_source_imgs/change_step.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s4VTQ4v1-1691832408842)(java_source_imgs/change_step2.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DXzzt6XX-1691832408843)(java_source_imgs/change_step3.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2RE7kxXi-1691832408844)(java_source_imgs/change_step4.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B9j27g3Y-1691832408845)(java_source_imgs/change_step5.jpg)]

情况7

当前节点为父结点的右子树，父结点为祖父节点的右子树（三者在同一条直线上）

解决办法：直接以父结点进行左旋，并将父结点设置为黑色，祖父节点设置为红色。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1OqCK7WI-1691832408846)(java_source_imgs/right_right_before.png)]

rotateLeft

左转的可能性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ILykvjqe-1691832408847)(java_source_imgs/rotateLeft .png)]

static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
                                      TreeNode<K,V> p) {
    TreeNode<K,V> r, pp, rl;
    if (p != null && (r = p.right) != null) {
        // r 结点表示 p 结点的右结点
        // p 结点存在，p 结点的右结点存在
        if ((rl = p.right = r.left) != null)
        // 如果 r的左结点存在，要把 左节点放置在  p 的右结点
            rl.parent = p;
        if ((pp = r.parent = p.parent) == null)
        // p.parent 父结点为空， root = r(不知道那种情况)
            (root = r).red = false;
        // pp 表示 p 结点的父结点
        else if (pp.left == p)
        // 如果 p 为 pp 的左孩子
            pp.left = r;
        else
        // 如果 p 为 pp 的右孩子
            pp.right = r;
        // 一定要让 r.left = p; p 的父结点 == r 
        r.left = p;
        p.parent = r;
    }
    
    return root;
}

rotateRight

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IiTQVlwr-1691832408848)(java_source_imgs/rotateRight.png)]

static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
                                       TreeNode<K,V> p) {
    TreeNode<K,V> l, pp, lr;
    if (p != null && (l = p.left) != null) {
    // 判断 p 和 p 的左结点是否为空
        if ((lr = p.left = l.right) != null)
        // p 的左结点等于 l 的右结点
            lr.parent = p;
        if ((pp = l.parent = p.parent) == null)
        // 如果，父结点为 空， 就将 root == r; 并把 r.red = false
            (root = l).red = false;
      	// pp 表示 p 的父结点
        else if (pp.right == p)
            pp.right = l;
        else
            pp.left = l;
        l.right = p;
        p.parent = l;
    }
    return root;
}

balanceInsertion

static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                            TreeNode<K,V> x) {
    x.red = true;
    for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
        // 1
        if ((xp = x.parent) == null) {
            x.red = false;
            return x;
        }
        // 2
        else if (!xp.red || (xpp = xp.parent) == null)
            return root;
        // 3 
        if (xp == (xppl = xpp.left)) {
            // 3.1
            if ((xppr = xpp.right) != null && xppr.red) {
                xppr.red = false;
                xp.red = false;
                xpp.red = true;
                x = xpp;
            }
            else { // 3.2
                if (x == xp.right) {
                    root = rotateLeft(root, x = xp);
                    xpp = (xp = x.parent) == null ? null : xp.parent;
                }
                if (xp != null) {
                    xp.red = false;
                    if (xpp != null) {
                        xpp.red = true;
                        root = rotateRight(root, xpp);
                    }
                }
            }
        }
        //4
        else {
            // 4.1
            if (xppl != null && xppl.red) {
                xppl.red = false;
                xp.red = false;
                xpp.red = true;
                x = xpp;
            }
            else { // 4.2
                if (x == xp.left) {
                    root = rotateRight(root, x = xp);
                    xpp = (xp = x.parent) == null ? null : xp.parent;
                }
                if (xp != null) {
                    xp.red = false;
                    if (xpp != null) {
                        xpp.red = true;
                        root = rotateLeft(root, xpp);
                    }
                }
            }
        }
    }
}
  1. xp == x.parent
  2. xpp == xp.parent
  3. xppl == xpp.left
  4. xppr == xpp.right

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DKGlIHcr-1691832408850)(java_source_imgs\balanceInsertNode.jpg)]

  1. 表示 x 就是根节点，直接插入，然后 修改 red == false

  2. 如果 父节点 不是 红色 或者
    xpp == null ;// 表示 xp 就是根节点，xp 的颜色肯定就是 黑色

  3. xp == xppl == xpp.left; 表示 x 的父节点 xp 是 祖父结点的左子树
    3.1 (xppr = xpp.right) != null && xppr.red 表示 右子树存在，并且是红色。直接 父节点和叔叔结点变黑，祖父结点变红
    ·3.2 表示叔叔结点为空或者为 黑色·

    （这里有一步 x = xp）,在旋转之后，x 转到最下面，然后方便 xp == x.parent; xpp = xp.parent

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hk4bCjyV-1691832408851)(java_source_imgs\balanceInsert_right_node.jpg)]

    // 表示当前结点 x 是 xp 的右子树，那么就需要左转
if (x == xp.right) {
    root = rotateLeft(root, x = xp);
    xpp = (xp = x.parent) == null ? null : xp.parent;
}

    // xp != null; 变成黑色，如果祖父结点不为空， 祖父结点变成红色，并且右转
if (xp != null) {
    xp.red = false;
    if (xpp != null) {
        xpp.red = true;
        root = rotateRight(root, xpp);
    }
}

split

/**
 * Splits nodes in a tree bin into lower and upper tree bins,
 * or untreeifies if now too small. Called only from resize;
 * see above discussion about split bits and indices.
 *
 * @param map the map
 * @param tab the table for recording bin heads
 * @param index the index of the table being split
 * @param bit the bit of hash to split on
 */
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    TreeNode<K,V> b = this;
    // Relink into lo and hi lists, preserving order
    TreeNode<K,V> loHead = null, loTail = null;
    TreeNode<K,V> hiHead = null, hiTail = null;
    int lc = 0, hc = 0;
    for (TreeNode<K,V> e = b, next; e != null; e = next) {
        next = (TreeNode<K,V>)e.next;
        e.next = null;
        // e.hash & bit == 0 说明 e.hash < bit，就会连接到 小段
        if ((e.hash & bit) == 0) {
            if ((e.prev = loTail) == null)
                loHead = e;
            else
                loTail.next = e;
            loTail = e;
            ++lc;
        }
        else { // 连接到 大段
            if ((e.prev = hiTail) == null)
                hiHead = e;
            else
                hiTail.next = e;
            hiTail = e;
            ++hc;
        }
    }
	// 如果小段不为空，
    if (loHead != null) {
        if (lc <= UNTREEIFY_THRESHOLD) // 小于 threshold 解数
            tab[index] = loHead.untreeify(map);
        else {
            tab[index] = loHead; // 将小段还放在 tab[index]
            if (hiHead != null) // (else is already treeified) 如果 hiHead != null, 说明
                loHead.treeify(tab);  // 需要重新树化
        }
    }
    if (hiHead != null) {
        if (hc <= UNTREEIFY_THRESHOLD)
            tab[index + bit] = hiHead.untreeify(map);
        else {
            tab[index + bit] = hiHead;
            if (loHead != null)
                hiHead.treeify(tab);
        }
    }
}

treeifyBin

如果 当前结点 个数大于 8个，就可以将链表转换成树，但是 treeifyBin 比较有意思的是，首先查看数组的长度是否小于64; 如果是这样，现在 数组扩容，而不是直接将链表转换成红黑二叉树

。// 然后最后在调用 hd.treeify(tab);

/**
 * Replaces all linked nodes in bin at index for given hash unless
 * table is too small, in which case resizes instead.
 */
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}
d = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}
Bourne_First
关注
专栏目录
hashMap实现原理
yjclsx的博客
07-31 43万+
1. HashMap概述： 　　HashMap是基于哈希表的Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的，也就是同步的）。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 2. HashMap的数据结构： 　　在java编程语言中，最基本的结构就是两种，一...
面试阿里，HashMap 这一篇就够了
热门推荐
程序员囧辉
05-25 7万+
HashMap 面试中可能问到的知识点，这边全都有
HashMap详解
java123456111的博客
03-09 5万+
一、HashMap集合简介 HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap 中的映射不是有序的。 jdk1.8 之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的 hashCode 方法计算的哈希值经哈希函数算出来的地址被别的元素占用）而存
hashMap
jxy11111的博客
08-02 2839
HashMap HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。HashMap的底层结构是一个数组，数组中的每一项是一条链表 HashMap的实例有两个参数影响其性能：“初始容量”和“装填因子” HashMap实现不同步，线程不安全，HashTable的线程安全 HashMap中的key-value都是存储在Entry中的 HashMap可以存null键和null值...
HashMap 源码分析
12-22
《HashMap 源码解析——JDK11版本》 HashMap是Java中广泛使用的非同步散列表，其设计和实现是高效且灵活的。在JDK1.8之前，HashMap的底层数据结构采用的是数组+链表的方式，这种方式称为“拉链法”来解决哈希冲突。...
易语言HashMap类
07-18
易语言HashMap类是一种在易语言编程环境中实现的高效数据结构，它主要用于存储键值对（key-value pairs），提供快速的数据存取。HashMap类基于哈希表（Hash Table）原理，通过计算键的散列值来确定数据在内存中的...
Java中HashMap和TreeMap的区别深入理解
09-05
HashMap和TreeMap是Java中两种常用的Map实现，它们各自具有不同的特性和使用场景。 HashMap是基于哈希表实现的，其核心思想是通过键对象的hashCode()方法来快速定位到对应的桶（bucket），从而提高查找效率。...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 318
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 570
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1091
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 132
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 588
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 888
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 323
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1149
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1044
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
服装|基于Java+vue的服装定制系统(源码+数据库+文档)
weixin_66413741的博客
09-10 714
服装定制将是广大用户们不可忽视的一块。但是管理好服装定制又面临很多麻烦需要解决,我们可以发现服装定制方面的系统并不是相当普及,在服装定制方面的可以有许多改进。即服装定制系统慢慢的被人们关注。服装定制管理方面的任务繁琐,以至于每年都在服装定制管理这方面投入较多的精力却效果甚微,
JAVA开源项目 在线视频教育平台 计算机毕业设计
as230627的博客
09-14 970
基于Vue.js和SpringBoot的在线视频教育平台是一个功能丰富的系统，它包括管理后台和用户网页端，为管理员、普通用户和教师角色提供了不同的功能。在管理后台，管理员可以进行用户管理，包括用户信息的增删改查。
HashMap数据结构与实现原理
"深入理解HashMap的实现原理" HashMap作为Java中常用的数据结构，是基于哈希表实现的，它提供了高效且灵活的键值对存储功能。HashMap的主要特点是它不保证映射的顺序，并且允许使用null值和null键。本文将深入探讨...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值