认真研究HashMap的结点移除

原创 已于 2022-08-22 11:12:37 修改 · 6.3k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#HashMap #结点移除

于 2016-09-21 15:00:13 首次发布

关联博文
数据结构之Map基础入门与详解
认真学习Java集合之HashMap的实现原理
认真研究HashMap的读取和存放操作步骤
认真研究HashMap的初始化和扩容机制
认真研究JDK1.7下HashMap的循环链表和数据丢失问题
认真研究HashMap中的平衡插入
认真研究HashMap中的平衡删除

前面系列博文，我们研究了HashMap的数据结构、get、put操作以及put后的红黑树平衡，本文我们分析HashMap的结点移除。本文基于jdk1.8环境。

我们常用的remove方法有如下两种，其本质都是委派给了removeNode方法。

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


@Override
public boolean remove(Object key, Object value) {
   return removeNode(hash(key), key, value, true, true) != null;
}

【1】removeNode

接下来我们详细分析removeNode方法，其中boolean matchValue表示只有和检测到的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;
    //定位到哈希桶中位置
    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;

        // 直接检索到-挺幸运
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
        
        //否则就向后遍历，又区分链表和红黑树
            if (p instanceof TreeNode)
            	//从红黑树中遍历	
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
           
            else {
            	// 链表遍历
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } 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;//把node割离出来

			//结构调整计数器+1
            ++modCount;
	        // 总数目-1
            --size;
            
            //移除后的操作 linkedhashmap实现了这个方法
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

可以看到整体流程还是很清晰的，这里麻烦在于树结点的查找和移除。

【2】树节点的查找

如下所示，其首先判断当前结点是否为根节点，然后触发find方法。也就是说要保证从根节点开始往下遍历查找。

final TreeNode<K,V> getTreeNode(int h, Object k) {
    return ((parent != null) ? root() : this).find(h, k, null);
}

我们继续看find方法，h表示hash(key),k就是key。

final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
    TreeNode<K,V> p = this;
    do {
        int ph, dir; K pk;
        TreeNode<K,V> pl = p.left, pr = p.right, q;
       
        // 大于h就往左侧找
        if ((ph = p.hash) > h)
            p = pl;
         //小于h就往右侧找   
        else if (ph < h)
            p = pr;
        //key相等--太幸运了直接返回    
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        
        // hash值相等的情况下
        //如果pl为null，就往右侧找   
        else if (pl == null)
            p = pr;
        //如果pr为null，就往左侧找    
        else if (pr == null)
            p = pl;
        // 都不为null，就必须确定是pl 还是pr ，首先使用compareTo进行比较
        else if ((kc != null ||
                  (kc = comparableClassFor(k)) != null) &&
                 (dir = compareComparables(kc, k, pk)) != 0)
                 //尝试触发compareTo方法 如果k<pk 则p=ol 否则p=pr
            p = (dir < 0) ? pl : pr;
        //迫于无奈往右侧寻找    
        else if ((q = pr.find(h, k, kc)) != null)
            return q;
        else
        // 最后p=pl往左侧寻找
            p = pl;
    } while (p != null);
    return null;
}

comparableClassFor： 如果对象x的类是C，如果C实现了Comparable<C>接口，那么返回C，否则返回null。这个方法的作用就是查看对象x是否实现了Comparable接口

compareComparables：如果x的类型是kc，返回k.compareTo(x)的比较结果。如果x为空，或者类型不是kc，返回0

方法流程梳理如下：

  • 如果ph>h，则将pl赋予p;
  • 如果ph<h，则将pr赋予p;
  • 如果ph==h,且pk==k , 直接返回p;
  • 如果pl == null，则p=pr;从右侧找
  • 如果pr == null，则 p = pl;从左侧找
  • 如果kc不为null，尝试调用其compareTo方法进行比较，如果k<pk 则p=pl 否则p=pr;
  • 最后手段如果q = pr.find(h, k, kc)!=null，返回q;也就是从右侧找
  • 最终手段，直接 p = pl;往左侧找
  • 如果前面没有return，且p不为null，则进行下次循环。否则返回null

总结就是根据hash判断左右，然后根据左右是否为null确定左右。如果尝试使用compareTo得不到左右分支那么就尝试在右侧分支查找，最终去左侧分支查找。

【3】树节点的删除

代码如下所示，首先确定当前哈希桶中索引位置，也就是int index = (n - 1) & hash：

  • ① 进行prev、next的处理
  • ② 确定replacement
  • ③ 使用replacement替代掉当前结点
  • ④ 移除后的树平衡
  • ⑤ 将root指定到tab[index]位置。

其中关于第二步确定replacement，如果pl且pr不为null，那么需要找到当前结点p的后继结点交换颜色、交换位置，然后尝试使用后继结点的right替代掉p(如果后继结点的right存在)。

//前置触发
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);

//如下hash是当前结点的hash
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
                          boolean movable) {
    int n;
    if (tab == null || (n = tab.length) == 0)
        return;
     
     // 结点所在桶的位置   
    int index = (n - 1) & hash;

	//确定当前hash位置的头结点first，并赋予root=first
    TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;

    //记录当前结点的next、prev
    TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;

	//说明当前结点是头结点，那么直接将next前移
    if (pred == null)
        tab[index] = first = succ;
    else
        pred.next = succ;//node.prev.next = node.next 把node割离出来
    
	//如果next结点存在，node.next.prev=node.prev 把node割离出来
	if (succ != null)
        succ.prev = pred;
// ---------注意，到这里，当前结点node前后 prev next已经改变----------------
    
    //first什么情况下为null？    
    //first为null的情况下无需额外处理，直接返回即可
    if (first == null)
        return;
     
     //确认根节点   
    if (root.parent != null)
        root = root.root();
    
    //转化为链表    
    if (root == null || root.right == null ||
        (rl = root.left) == null || rl.left == null) {
        tab[index] = first.untreeify(map);  // too small
        return;
    }

	// p 表示当前结点
    TreeNode<K,V> p = this, pl = left, pr = right, replacement;

-----------------------------------确定replacement----------------------------------
	// 如果pl 、 pr都不为null
    if (pl != null && pr != null) {
        TreeNode<K,V> s = pr, sl;
       
        // s 为右侧子树的最小左孩子，也就是当前结点的后继结点
        while ((sl = s.left) != null) // find successor
            s = sl;

        //交换后继结点与当前结点的颜色 --第一步  
        boolean c = s.red; s.red = p.red; p.red = c; // swap colors
        
        //sr可能为null， 后继结点的right
        TreeNode<K,V> sr = s.right;
        TreeNode<K,V> pp = p.parent;
        
        //p没有左孩子，只有右孩子，且右孩子没有左孩子， 交换sp
        if (s == pr) { // p was s's direct parent
            p.parent = s;
            s.right = p;
        }
        else {
        // p 与 s 交换位置，此时P还在树结构中哦 -第二步
            TreeNode<K,V> sp = s.parent;
            if ((p.parent = sp) != null) {
                if (s == sp.left)
                    sp.left = p;
                else
                    sp.right = p;
            }
            if ((s.right = pr) != null)
                pr.parent = s;
        }

		//因为前面s.left为null
        p.left = null;

		//sr的新parent为p
        if ((p.right = sr) != null)
            sr.parent = p;
		//pl的新parent为s
        if ((s.left = pl) != null)
            pl.parent = s;
        
        //s的新parent为pp,如果为null，那么 s 就是root    
        if ((s.parent = pp) == null)
            root = s;
         
         //如果 p 是 pp 的左孩子，那么新的左孩子是s   
        else if (p == pp.left)
            pp.left = s;
        else
            pp.right = s;
        
        // 确定替换结点--也就是哪个结点替换p
        //1.P与后继结点交换；
        //2.“替换结点”替代掉P
        if (sr != null)
            replacement = sr;
        else
            replacement = p;
    }
    // pl不为null，pr为null
    else if (pl != null)
        replacement = pl;
    //    pr不为null，pl为null
    else if (pr != null)
        replacement = pr;
    //     pl=pr=null
    else
        replacement = p;

----------------------------------------------------------------     
     //这一步是用   replacement替换掉 p  --第三步 注意这时 replacement != p
     // replacement 比如sr pl pr
    if (replacement != p) {
        TreeNode<K,V> pp = replacement.parent = p.parent;
        if (pp == null)
            root = replacement;
        else if (p == pp.left)
            pp.left = replacement;
        else
            pp.right = replacement;

        // p 从树结构中脱离    
        p.left = p.right = p.parent = null;
    }
	
	//同平衡插入一样，这里有平衡删除，也就是移除结点后进行平衡  --第四步
    TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);

 // 第三步的第二种情况，比如pr pl都为null，或者sr为null，
 // 这一步同样是把p从树结构中割离
    if (replacement == p) {  // detach
        TreeNode<K,V> pp = p.parent; 
        p.parent = null;
        if (pp != null) {
            if (p == pp.left)
                pp.left = null;
            else if (p == pp.right)
                pp.right = null;
        }
    }
    // 把root结点移动到tab[index]位置
    if (movable)
        moveRootToFront(tab, r);
}

最后我们再看一下删除结点后的树的平衡吧。也就是balanceDeletion(root, replacement)方法。关于这个可以参考博文：认真研究HashMap中的平衡删除，本文限于篇幅不再赘述。

【Android面试题八股文】说HashMap，SparseArrary原理，SparseArrary相比HashMap的优点、concurrentHashMap如何实现线程安全?
字节卷动
06-05 678
请说-说HashMap，SparseArrary原理，SparseArrary相比HashMap的优点、concurrentHashMap如何实现线程安全? 这道题想考察什么 ? 考察的知识点 考生如何回答 HashMap的基本原理 SparseArray的基本原理 SparseArray的优点 SparseArray的缺点 什么情况下我们使用SparseArray代替HashMap ArrayMap ConcurrentHashMap基本原理
hashMap
TU_JCN的博客
09-04 663
在jdk1.8里，对数据结构做了进一步优化，引入了红黑树，当链表长度大于8的时候，链表就会转成红黑树，利用红黑树快速增删改查的特点提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。作为不可变类天生是线程安全的，当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。
java哈希map 删除_HashMap1.8之节点删除分析
weixin_33355290的博客
02-23 326
HashMap之节点删除大家一直关注的都是HashMap如何添加节点，当节点数量大于8的时候转化为红黑树，否则使用链表等等，但大家是否有看过删除节点的处理逻辑呢？ 今天来看看HashMap删除节点的神来之笔问题来源在查看HashMap源码时，有个以下字段，在删除的时候，判断节点数量，最多在小于6的时候，会untreeifying(树转化为链表)，在点击这个字段时发现，只有在split()方法中使用...
hashmap 详解
huapro.vip的程序人生
02-11 788
hash map
HashMap解读
zhangshuai66的博客
08-10 1335
HashMap源码简单的阅读
如何优雅的删除HashMap元素
青鱼入云的博客
11-21 1287
需要注意增强的 for 循环底层使用的迭代器 Iterator，而 HashMap 是 fail-fast 原则的错误机制，所以遍历时删除元素会出现 java.util.ConcurrentModificationException 并发修改异常。通过Iterator迭代删除元素不会出现并发修改异常，但由于HashMap是线程不安全的，这时如果多个线程同时修改HashMap数据也会出现并发修改异常 ，日常使用可以先用ConcurrentHashMap封装。所以也存在第三种方法同样的问题。
HashMap源码复习之移除节点元素
搁浅沉默的博客
03-30 420
移除节点元素： final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { //tab：引用当前hashMap中的散列表 //p：当前node元素 //n：表示散列表数组...
研究HashMap----常见问题
不洇的博客
08-11 496
文章目录HashMap的遍历通过反射查看HashMap的容量HashMap的null值(h = key.hashCode()) ^ (h >>> 16)的原因HashMap的最大容量为什么是1<<30，而不是1<<31HashMap的默认负载因子为什么是0.75，而不是0.8,0.6我们可以初始化容量大小，那么扩容阈值问题是怎么保证的。 HashMap的遍历 public static void test(){ HashMap<Stri
HashMap分析
彬
04-19 379
HashMap分析第1部分 HashMap介绍第2部分 HashMap数据结构第3部分 HashMap源码解析(基于JDK-8u201)内部类Node三个内部集合类内部类Iterator内部类Spliterator内部类TreeNodeHashMap源码第4部分 HashMap使用示例 第1部分 HashMap介绍 HashMap简介 HashMap实现了Map接口，提供关于K,V和Entry的操...
手撕HashMap
knight20160302的博客
08-20 355
HashMap 主要用来存放键值对，它基于哈希表的Map接口实现，是常用的Java集合之一。 JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树，以减少搜索时间。本文主要基于JDK1.8之前的...
HashMap 之元素删除
weixin_33929309的博客
09-18 3761
微信公众号：I am CR7如有问题或建议，请在下方留言;最近更新：2018-09-18 HashMap之元素删除 继上一篇HashMap之元素插入，我们继续来看下元素删除的实现原理。 1、源码： 1publicVremove(Objectkey){2Node&lt;K,V&gt;e;3return(e=removeNode(hash(key),...
hashmap移除元素_JAVA中HashMap如何删除元素
weixin_42519126的博客
02-15 4426
HashMap删除元素根据其遍历方式一般有两种方法，实例演示如下：一、采用foreach模式，适用于不需要修改HashMap内元素的遍历，只需要获取元素的键/值的情况。1、遍历如下：2、此时删除HashMap中的元素，Java很有可能会在运行时抛出异常。运行上面的代码，Java抛出了java.util.ConcurrentModificationException的异常。并附有如下信息。可以推测，...
hashmap移除元素_HashMap1.8 源码解析(2)--删除元素
weixin_29669899的博客
01-27 387
完整代码:代码前言删除删除有两种方式:1. remove(Object key)根据key删除2. remove(Object key, Object value) 根据key和value删除注意:只有扩容,没有说删除后缩小容量这个操作./*** 注意与remove(Object key)不同的两点:* 1. 要根据key,value同时符合才可以删除该节点* 2. 返回值是true 表明正确...
hashmap移除元素_一文带你了解并发 HashMap 的一种简单实现
weixin_28725959的博客
12-25 517
前言java.util.concurrent.ConcurrentHashMap,java.util.concurrent.ConcurrentHashMap 虽然效果不错，但其实现相当复杂。在开发一款工具的过程中，由于无法使用 java.util.concurrent.ConcurrentHashMap (工具的目标之一就是跟踪 ConcurrentHashMap 内部实现) 因此笔者决定自己实...
hashmap移除元素_HashMap1.8之节点删除分析
weixin_39928102的博客
12-31 327
HashMap之节点删除大家一直关注的都是HashMap如何添加节点，当节点数量大于8的时候转化为红黑树，否则使用链表等等，但大家是否有看过删除节点的处理逻辑呢？ 今天来看看HashMap删除节点的神来之笔问题来源在查看HashMap源码时，有个以下字段，在删除的时候，判断节点数量，最多在小于6的时候，会untreeifying(树转化为链表)，在点击这个字段时发现，只有在split()方法中使用...
深入解析 HashMap 的 remove() 方法及其相关实现
qq_41934990的博客
10-15 1592
HashMap 是 Java 中最常用的集合类之一，它提供了高效的键值对存储和检索功能。本文将详细解析 HashMap 的 remove() 方法及其相关的内部实现，包括 removeNode() 和 removeTreeNode() 方法。通过这些方法，我们可以了解 HashMap 如何高效地移除指定的键值对，并在必要时重新平衡红黑树结构。给出大致流程图，让我们来跟着流程图看源码。
【HashMap】遍历读和遍历删除
weixin_44823875的博客
09-12 1492
【5】方法五：stream流遍历以及lambda表达式遍历。【4】方法四：entrySet()迭代。【3】方法三：keySet()迭代。【一】遍历读HashMap。【1】方法一：for循环。【2】方法二：迭代器。
认真研究HashMap中的平衡删除
小小默：进无止境
02-24 8788
**关联博文** [数据结构之Map基础入门与详解](https://janus.blog.youkuaiyun.com/article/details/53214105) [认真学习Java集合之HashMap的实现原理](https://janus.blog.youkuaiyun.com/article/details/86774652) [认真研究HashMap的读取和存放操作步骤](https://janus.blog.youkuaiyun.com/article/details/52787823) [认真研究HashMap的初始化和
如何手搓hashmap
最新发布
05-25
### 手动实现哈希表（HashMap）的数据结构和相关算法 以下是基于 Java 编程语言的手写 HashMap 数据结构及其核心方法的完整代码与原理说明： --- #### 1. 基本概念 HashMap 是一种基于键值对存储数据的数据结构，它利用哈希函数将键映射到底层数组的位置。为了应对哈希冲突，通常采用链地址法（即链表或红黑树）。在 JDK 8 及以上版本中，当链表长度达到一定阈值时会自动转换为红黑树以优化性能[^4]。 --- #### 2. 核心组件 - **Node 类**：表示键值对节点。 - **数组**：作为底层容器用于存储 Node 节点。 - **哈希函数**：负责计算键的哈希码并将其映射到数组索引。 - **扩容机制**：当负载因子超过设定值时触发容量翻倍操作。 --- #### 3. 完整代码实现 ```java import java.util.Objects; // 自定义 Node 类 class MyNode<K, V> { final int hash; // 键的哈希值 final K key; // 键 V value; // 值 MyNode<K, V> next; // 链表指针 public MyNode(int hash, K key, V value, MyNode<K, V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } @Override public String toString() { return key + "=" + value; } } // 自定义 HashMap 类 public class MyHashMap<K, V> { private static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认初始容量为 16 private static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认加载因子为 0.75 private int size; // 当前元素数量 private int threshold; // 阈值 = capacity * loadFactor private final float loadFactor; // 加载因子 private MyNode<K, V>[] table; // 底层数组 // 构造器 public MyHashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); } public MyHashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Initial Capacity: " + initialCapacity); if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal Load Factor: " + loadFactor); this.loadFactor = loadFactor; this.threshold = (int) Math.min(initialCapacity * loadFactor, Integer.MAX_VALUE); this.table = (MyNode<K, V>[]) new MyNode[initialCapacity]; } // 获取指定键对应的值 public V get(K key) { if (key == null) return null; int hash = hash(key); MyNode<K, V> node = getNode(hash, key); return (node != null) ? node.value : null; } // 添加键值对 public void put(K key, V value) { if (key == null) return; int hash = hash(key); MyNode<K, V> newNode = new MyNode<>(hash, key, value, null); addNode(hash, newNode); } // 删除指定键的条目 public V remove(K key) { if (key == null) return null; int hash = hash(key); MyNode<K, V> prev = null; MyNode<K, V> current = table[hash & (table.length - 1)]; while (current != null && !Objects.equals(current.key, key)) { prev = current; current = current.next; } if (current == null) return null; // 未找到对应键 if (prev == null) { // 删除头结点 table[hash & (table.length - 1)] = current.next; } else { // 删除中间/尾部节点 prev.next = current.next; } size--; return current.value; } // 辅助方法：获取指定键所在的节点 private MyNode<K, V> getNode(int hash, K key) { MyNode<K, V> node = table[hash & (table.length - 1)]; while (node != null && !(Objects.equals(node.key, key))) { node = node.next; } return node; } // 辅助方法：添加新节点 private void addNode(int hash, MyNode<K, V> newNode) { if (size >= threshold) resize(); // 判断是否需要扩容 int index = hash & (table.length - 1); // 计算插入位置 MyNode<K, V> head = table[index]; if (head == null) { // 若当前位置为空，直接插入 table[index] = newNode; } else { // 否则加入链表头部 newNode.next = head; table[index] = newNode; } size++; } // 辅助方法：重新调整大小 private void resize() { int oldCap = table.length; int newCap = oldCap << 1; // 新容量加倍 MyNode<K, V>[] oldTable = table; MyNode<K, V>[] newTable = (MyNode<K, V>[]) new MyNode[newCap]; for (int i = 0; i < oldCap; ++i) { MyNode<K, V> node = oldTable[i]; if (node != null) { oldTable[i] = null; // 清理旧表 MyNode<K, V> next; do { next = node.next; int newIndex = node.hash & (newCap - 1); node.next = newTable[newIndex]; // 插入到新表头部 newTable[newIndex] = node; node = next; } while (node != null); } } table = newTable; threshold = (int) (newCap * loadFactor); } // 辅助方法：计算哈希值 private int hash(K key) { int h; return (key == null) ? 0 : ((h = key.hashCode()) ^ (h >>> 16)); } // 输出所有键值对 public void display() { System.out.println("["); for (MyNode<K, V> node : table) { StringBuilder sb = new StringBuilder(); while (node != null) { sb.append(node.toString()).append(", "); node = node.next; } if (!sb.isEmpty()) sb.setLength(sb.length() - 2); // 移除最后一个逗号 System.out.println(sb.toString()); } System.out.println("]"); } } ``` --- #### 4. 关键点解析 - **哈希函数的设计**： 哈希函数的目标是均匀分布键值对，减少哈希冲突的发生概率。上述代码中采用了 `(hashCode() ^ (hashCode() >>> 16)) % length` 的方式来提高低位随机性[^1]。 - **链表转红黑树**： 在 JDK 8 中引入了红黑树的概念，当链表长度超过 8 并且数组长度大于等于 64 时，链表会升级为红黑树以降低时间复杂度[^3]。此功能可以进一步扩展至手写的 HashMap 中。 - **扩容机制**： 当 HashMap 的填充率接近预设的最大值时，会触发扩容操作，即将原数组复制到一个新的两倍大小的数组中，并重新分配所有的键值对[^2]。 --- #### 5. 测试案例 ```java public class Main { public static void main(String[] args) { MyHashMap<String, Integer> map = new MyHashMap<>(); map.put("Alice", 25); map.put("Bob", 30); map.put("Charlie", 35); System.out.println(map.get("Alice")); // 输出 25 System.out.println(map.get("Bob")); // 输出 30 map.remove("Bob"); System.out.println(map.get("Bob")); // 输出 null map.display(); // 显示所有键值对 } } ``` ---
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

流烟默

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值