java集合的迭代器与遍历

今天药忘吃喽~ 2024-02-05 14:58 66阅读 0赞

#### 文章目录 ####

*  迭代器
 *   *  Iterator
     *   *  1、什么是Iterator
         *  2，iterator接口的API
         *  3、Irerator()方法细节解释
         *  4. Irerator的原理示意图
         *  4. 1 Irerator的案例
         *  5. forEach循环与Iterator遍历的区别与联系
         *  6. for循环与增强for循环的区别
     *  ListIterator
     *   *  1.ListIterator的概述
         *   *  (1) 概念
             *  (2) 解析
         *  2.ListIterator的生成
         *  3.ListIterator的API
         *  4.ListIterator的add方法解析
         *  5.ListIterator与Iterator的区别
 *  java集合遍历
 *   *  1. ArrayList的遍历方式
     *   *  第一种，通过迭代器遍历。即通过Iterator去遍历。
         *  第二种，随机访问index，通过索引值去遍历。
         *  第三种，增强for循环遍历。如下：
         *  第四种，forEach遍历。如下：
         *  第五种，stream流式遍历
         *  第六种，forEachRemaining方法遍历：继续输出其余的元素
     *  2. LinkedList的遍历方式
     *   *  第七种：通过pollFirst()来遍历LinkedList，获取并移除此列表的第一个元素；如果此列表为空，则返回 null
         *  第八种：通过pollLast()来遍历LinkedList，获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
         *  第九种：通过removeFirst()来遍历LinkedList，移除并返回此列表的第一个元素。 NoSuchElementException - 如果此列表为空。
         *  第十种：通过removeLast()来遍历LinkedList，移除并返回此列表的最后一个元素。NoSuchElementException - 如果此列表为空。
     *  3. Set集合的遍历方式
     *  4. Map集合的遍历方式
     *   *  ①for-each + keySet()/values()遍历key/Value
         *  ②\[重要\]for-each + entrySet()遍历
         *  ③for-each + keySet() + get()方法遍历
         *  ④Iterator + entrySet()遍历
         *  ⑤\[重要\]lambda表达式遍历
         *  ⑥stream流遍历
         *  总结——简洁又好用的遍历方式

## 迭代器 ##

### Iterator ###

#### 1、什么是Iterator ####

**迭代的概念**: Collection集合元素的通用获取方式，再取元素之前要先判断集合中有没有元素，如果有，就把这个元素取出来，继续在进行判断，如果还有就再取出来，一直把集合中的所有元素取出，这种取出方式专业术语就叫做迭代

一些集合类提供了内容遍历的功能，通过java.util.Iterator接口。这些接口允许遍历对象的集合。依次操作每个元素对象。当使用 Iterators时，在获得Iterator的时候包含一个集合快照。通常在遍历一个Iterator的时候不建议修改集合本身。  
　　2、Iterator与ListIterator有什么区别？  
　　Iterator：只能正向遍历集合，适用于获取移除元素。ListIerator：继承Iterator，可以双向列表的遍历，同样支持元素的修改。

#### 2，iterator接口的API ####

boolean hasNext()  如果仍有元素就可以迭代，返回的就是true，
     判断集合中还有没有下一个元素，有就返回true，没有就返回false
     E next() 返回迭代的下一个元素。
     void remove()  从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。
    
    Iterator也是一个接口，我们无法直接使用，需要使用Iterator接口的实现类。
    在Collection接口中有一个方法，Iterator（），这个方法的返回值就是迭代器的实现类

#### 3、Irerator()方法细节解释 ####

> Iterator iterator = col.iterator();//获取迭代器对象  
> hasNext(): 判断游标右边是否还有下一个元素，默认游标都在集合的第一个元素之前。  
> 注意：此时只是判断是否有下一个元素，并不移动指针。  
> while(iterator.hasNext())\{  
> //next():①指针下移 ②将下移以后集合位置上的元素返回  
> Object next = iterator.next();  
> System.out.println(“next=”+next);  
> \}

迭代过程如图所示：  
![在这里插入图片描述][789ed0f56699450eab40b3c0eca19ba6.png]  
(1)、如果iterato.next()指向的内存中如果没有元素会抛出异常  
(2)、当退出while后，iterator.hasNext()中next已经走到尾部，若继续调用iterator.hasNext()将会报错（若要继续遍历，可通过重置迭代器解决）  
(3)、void remove()方法 ：删除当前指针所指向的元素，一般和next方法一起用，这时候的作用就是删除next方法返回的元素，如果当前指针指向的内存中没有元素，那么会抛出异常

#### 4. Irerator的原理示意图 ####

![在这里插入图片描述][9eb60b7b4e804d1ab6162fa3226b39b2.png]

#### 4. 1 Irerator的案例 ####

Collection coll = new ArrayList(); //面向对象中的多态coll.add(1);
            coll.add("abc");
            coll.add(1.23);
            coll.add("张三");
     for(Iterator it = coll.iterator();it.hasNext();){
        
               Object obj = it.next();
               System.out.println(obj);//输出1  abc   1.23   张三
           }
           
      Iterator it = coll.iterator();
            while(it.hasNext()){
        
               Object obj =  it.next();
                System.out.println(obj);//输出结果；1  abc   1.23  张三
            }

![在这里插入图片描述][7f6058ab6c3e4628979908d67d63720b.png]

#### 5. forEach循环与Iterator遍历的区别与联系 ####

（1）使用范围不同

forEach: 不仅可以在集合中使用，也可以在数组中遍历使用
    Iterator：专门为遍历集合而生，集合并没有提供专门的遍历的方法。在数组中不能遍历用

（2）遍历过程不同

iterator.remove() 删除当前遍历到的值
    foreach遍历集合元素时不能调用remove删除元素，否则会出现ConcurrentModificationException

（3）增强的for循环和Iterator的联系

增强的for循环(遍历集合)时，底层使用的是Iterator
    凡是可以使用增强的for循环(遍历的集合)，肯定也可以使用Iterator进行遍历

#### 6. for循环与增强for循环的区别 ####

（1）.语法上的区别
    for循环使用初始变量、循环条件、迭代语句控制运行的执行，增强for使用中间变量、迭代数据进行循环的执行
    （2）.获取数据的区别
    for循环在循环的过程中使用迭代数据的方法进行数据的获取,增强方法循环使用的是内部判断，是否存在数据
    （3）.循环控制上的区别
    for循环可以根据迭代语句动态控制循环的终止与执行，增强for循环只能进行从头到尾的迭代
    （4）.数据操作的区别
    for循环使用迭代数据的方法可以在循环中对数据进行修改，增强for循环使用中间变量，
    数据与存储在迭代数据中的数据没有关联不能修改

### ListIterator ###

#### 1.ListIterator的概述 ####

##### (1) 概念 #####

> 官方文档说，此接口只是用于List的迭代器，通过它我们可以从任意方向遍历列表、在迭代期间修改列表、获取迭代器在列表中的当前位置。ListIterator没有当前元素(current element)，它的光标总是处于调用previous()方法返回的元素和next()方法返回的元素之间。长度为n的列表，它的迭代器有n+1个光标位置

![在这里插入图片描述][7e2735fd4d094d1096e7139524bd0c1e.png]  
绿色代表ListIterator迭代器的位置，在ListItarator中迭代器的位置都是指的光标的位置。红色代表List列表中的元素，把这张图存脑袋里，把这张图存脑袋里，把这张图存脑袋里，这个接口的所有操作都没啥障碍了。

##### (2) 解析 #####

在使用java集合的时候，都需要使用Iterator。但是java集合中还有一个迭代器ListIterator,在使用List、ArrayList、LinkedList和Vector的时候可以使用。这两种迭代器有什么区别呢？下面我们详细分析。这里有一点需要明确的时候，迭代器指向的位置是元素之前的位置，如下图所示：  
![在这里插入图片描述][9a4d246860cb4ea7a251985c3549f023.png]  
这里假设集合List由四个元素List1、List2、List3和List4组成，当使用语句Iterator it = List.Iterator()时，迭代器it指向的位置是上图中Iterator1指向的位置，当执行语句it.next()之后，迭代器指向的位置后移到上图Iterator2所指向的位置。

#### 2.ListIterator的生成 ####

List<Integer> list =Arrays.asList(1,2,3,4);
     ListIterator<Integer> it = list.listIterator();                无参
     ListIterator<Integer> it1 = list.listIterator(list.size());    有参

#### 3.ListIterator的API ####

`add(E e):` 将指定的元素插入列表，插入位置为迭代器当前位置之前  
`hasNext()：`以正向遍历列表时，如果列表迭代器后面还有元素，则返回 true，否则返回false  
`hasPrevious():` 如果以逆向遍历列表，列表迭代器前面还有元素，则返回 true，否则返回false  
`next()：`返回列表中ListIterator指向位置后面的元素  
`nextIndex():` 返回列表中ListIterator所需位置后面元素的索引  
`previous():` 返回列表中ListIterator指向位置前面的元素  
`previousIndex()：`返回列表中ListIterator所需位置前面元素的索引  
`remove():` 从列表中删除最后一次执行next()或previous()方法返回的元素。（有点拗口，意思就是对迭代器使用hasNext()方法时，删除ListIterator指向位置后面的元素；当对迭代器使用hasPrevious()方法时，删除ListIterator指向位置前面的元素）  
remove使用时注意三点：

1.调用remove()方法之前，一定要有next()或previous()方法执行，
         否则报错：java.lang.IllegalStateException
       2.执行next() 或 previous()之后与执行remove()之前，不能执行add(E)方法，
       '否则报错： java.lang.IllegalStateException
       3.就近原则。

`set(E e)：`从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e  
在`调用set(E)方法前，不能调用remove() 和 add(E) 方法`，否则会报错：java.lang.IllegalStateException。

#### 4.ListIterator的add方法解析 ####

void add ( E e ) 将指定元素插入到previous()返回的元素与当前光标位置之间。如何理解呢？上图：  
![在这里插入图片描述][35c06b594d5542598186c1091ed04030.png]  
就是说不仅将元素插入到e1和e2之间，也插入到了e1和cursor之间。  
![在这里插入图片描述][c8b872ae46a047f4ab9d82e25beb674e.png]  
此时调用next()方法，仍然返回的是e2，调用previous()返回的就是新插入的元素了。  
值得注意的是，当光标位置处于0（第一个元素左边）时，调用add(E)方法会出现异常，因为现在光标左边还没有元素呀

#### 5.ListIterator与Iterator的区别 ####

一．相同点

都是迭代器，都可以对集合中的元素进行遍历 。当需要对集合中元素进行遍历不需要干涉其遍历过程时，这两种迭代器都可以使用。

二．不同点

（1）: 范围不同：Iterator可应用于Collection及其子类型所有的集合，
          而ListIterator只能用于List及其子类型，如List、ArrayList、LinkedList和Vector等
    （2）: 遍历功能略微不同：Iterator和ListIterator都有hasNext()和next()方法，可以实现顺序向后遍历，
          但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。
          Iterator则不可以逆向遍历。即 ListIterator 因为有hasPrevious()和previous()方法，所以可实现双向遍历，
          而terator只能单向顺序向前遍历。
    （3）: Iterator在遍历过程中仅仅有一个remove移除元素的方法， 故Iterator在遍历过程中不能够往集合里新增、修改元素；
          而ListIterator在遍历过程中有add()方法、remove方法、set方法，
          可以在遍历过程中向List中添加/删除集合中的元素，或者修改集合元素。
    （4）: Iterator在遍历过程中不能定位到索引位置，
          ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。
     注意： map并没有实现Iterator，ListIterator接口,所以其不能使用这两种迭代器直接进行遍历

## java集合遍历 ##

### 1. ArrayList的遍历方式 ###

#### 第一种，通过迭代器遍历。即通过Iterator去遍历。 ####

List<Integer> list =Arrays.asList(1,2,3,4);
    Iterator<Integer>  iter = list.iterator();
    while (iter.hasNext()) {
        
     Integer  value = iter.next();
     System.out.println("v..."+value);
    }
    
    或者通过for的方式
    List<Integer> list =Arrays.asList(1,2,3,4);
    for(Iterator iter = list.iterator(); iter.hasNext();){
        
     Integer  value = iter.next();
     System.out.println("v..."+value);
    }

#### 第二种，随机访问index，通过索引值去遍历。 ####

由于ArrayList实现了RandomAccess接口，它支持通过索引值去随机访问元素。

List<Integer> list =Arrays.asList(1,2,3,4);
    for (int i=0; i<list.size(); i++) {
        
        System.out.println("i= "+i+"....v..."+list.get(i));      
    }

#### 第三种，增强for循环遍历。如下： ####

List<Integer> list =Arrays.asList(1,2,3,4);
    for (Integer value : list) {
        
        System.out.println("v..."+value);
    }

#### 第四种，forEach遍历。如下： ####

List<Integer> list =Arrays.asList(1,2,3,4);
    list.forEach(v->System.out.println("v..."+value));
    也可以简写为
    list.forEach(System.out::println);

#### 第五种，stream流式遍历 ####

List<Integer> list =Arrays.asList(1,2,3,4);
    list.stream.map(x->x++).collect(Collectors.toList());
    或者
    list.stream.forEach(v->System.out.println("v..."+value));

#### 第六种，forEachRemaining方法遍历：继续输出其余的元素 ####

由于某种原因导致遍历停止了，然后在通过foreachRemaing 遍历的时候，只会遍历剩余集合中还存在的元素。

ArrayList<Integer> arrayList=new ArrayList<>();
           for (int i = 0; i <10; i++) {
        
               arrayList.add(i);
           }
           System.out.println("迭代器第一次遍历");
               Iterator<Integer> iterator=arrayList.iterator();
               while(iterator.hasNext()){
        
                int num=iterator.next();
                   System.out.print(num);
                   if(num==5){
        
                       break;
                   }
               }
           System.out.println("");
           System.out.println("输出其余元素：");
           iterator.forEachRemaining(new Consumer<Integer>() {
        
               @Override
               public void accept(Integer s) {
        
                   System.out.print(s);
               }
           });

![在这里插入图片描述][ba95828a8f884bc9832151ed6176d936.png]

遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低

### 2. LinkedList的遍历方式 ###

`由于LinkedList与ArrayList实现同一个接口List，故ArrayList的六种遍历方式对于LinkedList同样适用`，这里只对LinkedList的特有遍历方式做解释说明  
数据准备：

List<Integer> list = new LinkedList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    
    知识回顾：
    pollFirst()：删除头；并且返回头，如果列表为空，则不会给出任何异常，并且返回null。 特有方法
    pollLast()：删除尾； 并且返回尾，如果列表为空，则不会给出任何异常，并且返回null。特有方法
    removeFirst(E e)：删除头，获取元素并删除，返回头；如果列表为空，抛出NoSuchElementException异常。 特有方法
    removeLast(E e)：删除尾；获取元素并删除，返回尾；如果列表为空，抛出NoSuchElementException异常。 特有方法

#### 第七种：通过pollFirst()来遍历LinkedList，获取并移除此列表的第一个元素；如果此列表为空，则返回 null ####

while(list.pollFirst() != null){
        
             
         }

#### 第八种：通过pollLast()来遍历LinkedList，获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 ####

while(list.pollLast() != null) {
        
    
     }

#### 第九种：通过removeFirst()来遍历LinkedList，移除并返回此列表的第一个元素。 NoSuchElementException - 如果此列表为空。 ####

try {
        
        while(list.removeFirst() != null) {
        
    	
    	}
    } catch (NoSuchElementException e) {
        
    }

#### 第十种：通过removeLast()来遍历LinkedList，移除并返回此列表的最后一个元素。NoSuchElementException - 如果此列表为空。 ####

try {
        
        while(list.removeLast() != null) {
        
         
         }
    } catch (NoSuchElementException e) {
        
    }

注意：增强for循环（也称为for each循环）是jdk 1.5以后出来的一个高级的for循环，专们用来遍历数组，`它的内部原理其实是Iterator迭代器`，所以在遍历的过程中，不能对集合进行`增删`操作；Iterator迭代器遍历时可以做删除

### 3. Set集合的遍历方式 ###

`set集合支持的遍历方式同ArrayList集合的六种遍历方式`，这里就不在列举了，有疑问的看ArrayList集合的遍历方式

### 4. Map集合的遍历方式 ###

#### ①for-each + keySet()/values()遍历key/Value ####

for-each：一种遍历形式

> 可以遍历集合或者数组，实际上是迭代器遍历的简化写法，也称增强for循环。  
> each表示每个；for-each表示循环数组或集合中的对象、数据。

keySet()方法：拿到全部的Key

> 将Map中所有的键(Key)存入到Set集合中。  
> Key表示键值；Set表示Set集合。

values()方法：拿到全部的Value

> 返回一个新的Iterator(迭代器)对象，该对象包含Map中存在的每个元素的值(Value)。  
> vluees是值的复数形式，表示它有很多的值。

HashMap<String, Integer> map1 = new HashMap<>();
    map1.put("小明", 1);
    map1.put("小红", 2);
    map1.put("小张", 3);
    
    //for-each + keySet()遍历key
    for (String key : map1.keySet()) {
         //遍历key
        System.out.println("key = " + key);
    }
    //for-each + values()遍历value
    for (Integer value : map1.values()) {
         //遍历value
        System.out.println("value = " + value);
    }
    
    遍历结果：
    key = 小明
    key = 小红
    key = 小张
    value = 1
    value = 2
    value = 3

一次只能取出Key的值或者Value的值，这样显然是很不方便的。

#### ②\[重要\]for-each + entrySet()遍历 ####

> Map.Entry是为了更方便的输出map键值对。一般情况下，想要输出Map中的key 和 value，就必须先得到key的集合keySet()，然后再循环每个key得到每个value。values()方法是获取集合中的所有值，不包含键，没有对应关系。而Entry可以一次性获得这两个值。

`entrySet()方法：拿到全部的键值对`

> 将Map中所有的键(Key)-值(Value)对存入到Set集合中，这个方法返回的是一个Set<Map.Entry<K,V>>。  
> entry表示条目、清单；Set表示Set集合。  
> entry里面的内容如下：  
> Key1, Value1  
> Key2, Value2  
> Key3, Value3  
> … , …  
> Key65535, Value65535

HashMap<String, Integer> map1 = new HashMap<>();
    map1.put("小明", 1);
    map1.put("小红", 2);
    map1.put("小张", 3);
    
    //for-each + entrySet()遍历
    for (Map.Entry<String, Integer> entry : map1.entrySet()) {
         
        System.out.print("key = " + entry.getKey());
        System.out.println(", value = " + entry.getValue());
    }
    
    执行结果：
    key = 小明, value = 1
    key = 小红, value = 2
    key = 小张, value = 3

Map.Entry是最常见也最常用的遍历Map的方式

#### ③for-each + keySet() + get()方法遍历 ####

get()方法：传入Key，返回对应的Value

> 将要返回的元素的键(Key)作为参数，找到并返回对应该键(Key)的值(Value)。  
> 如果没有找到键(Key)，返回undefined。  
> 因为键(Key)是唯一的，所以不用担心找到第一个后第二个不输出的问题。

HashMap<String, Integer> map1 = new HashMap<>();
    map1.put("小明", 1);
    map1.put("小红", 2);
    map1.put("小张", 3);
    
    //for-each + keySet() + get()方法遍历
    for (String key : map1.keySet()) {
        
        Integer value = map1.get(key);
        System.out.print("key = " + key);
        System.out.println(", value = " + value);
    }
    执行结果：
    key = 小明, value = 1
    key = 小红, value = 2
    key = 小张, value = 3

一般不推荐使用这种方法，因为多了一步根据key查找value的操作，效率会相对慢一些。写法和最开始的for-each遍历很相似，不同的是value使用了get()方法来获取。

> map.get(key)方法的底层实现：  
> 先调用Key的Hashcode方法得到哈希值，通过哈希算法得到对应的数组的下标，通过数组下标快速定位到某个位置上，如果这个位置上什么也没有，则返回null，如果这个位置上有单向链表，那么会拿着参数k和单项链表中的每个节点的k进行比较（equals()），如果所有的节点都返回false，那么最终该方法返回null，如果有一个节点的k和我们的k相匹配，那么该k节点所对应的value就是我们要找的value。  
> 原文链接：https://blog.csdn.net/qq\_51960163/article/details/117530311

#### ④Iterator + entrySet()遍历 ####

iterator() 方法：返回一个用于遍历当前集合的迭代器

HashMap<String, Integer> map1 = new HashMap<>();
    map1.put("小明", 1);
    map1.put("小红", 2);
    map1.put("小张", 3);
    
    //Iterator + entrySet()遍历
    Iterator<Map.Entry<String, Integer>> iter = map1.entrySet().iterator();
    while (iter.hasNext()) {
        
        Map.Entry<String, Integer> entry = iter.next();
        System.out.print("key = " + entry.getKey());
        System.out.println(", value = " + entry.getValue());
    }
    执行结果：
    key = 小明, value = 1
    key = 小红, value = 2
    key = 小张, value = 3

使用Iterator创建一个迭代器来遍历这个Map，和方法②类似，但区别在于：

for-each通常用于一次性遍历整个集合，大大提升了代码的简洁性和可阅读性，但期间无法控制遍历的过程。而Iterator通过hasNext()，next() 更好地控制便利过程的每一步。  
for-each在遍历过程中严禁改变集合的长度，且无法对集合的删除或添加等操作。而Iterator可以在遍历过程中对集合元素进行删除操作。

但是在idea编译器中，编译器会给出警告，提示说该写法可以简化，简化后的写法和for-each + entrySet()方法遍历一致：

for (Map.Entry<String, Integer> entry : map1.entrySet()) {
        
    	System.out.print("key = " + entry.getKey());
    	System.out.println(", value = " + entry.getValue());
    }

#### ⑤\[重要\]lambda表达式遍历 ####

forEach() 方法：遍历数组中每一个元素并执行特定操作

> Lambda表达式：能够非常简练地表达特定的操作行为。在遍历集合中的元素时，如果对每个元素都执行同样的操作，也可以用Lambda表达式来指定对元素的操作行为，从而简化遍历访问集合的代码。

HashMap<String, Integer> map1 = new HashMap<>();
    map1.put("小明", 1);
    map1.put("小红", 2);
    map1.put("小张", 3);
    
    //lambda表达式遍历
    map1.forEach((key, value) -> {
        
        System.out.print("key = " + key);
        System.out.println(", value = " + value);
    });
    
    执行结果：
    key = 小明, value = 1
    key = 小红, value = 2
    key = 小张, value = 3

forEach方法遍历了map1，同时获取到key和value的值。美观，简洁，大气。

#### ⑥stream流遍历 ####

> Stream流的作用：区别于IO流，用来对容器（集合，数组）操作进行书写简化，配合众多函数式接口以及lambda表达式，方法引用，集合的遍历，计数，过滤，映射,截取等操作变得异常优雅，上流。

HashMap<String, Integer> map1 = new HashMap<>();
    map1.put("小明", 1);
    map1.put("小红", 2);
    map1.put("小张", 3);
    
    //stream流遍历
    map1.entrySet().stream().forEach((Map.Entry<String, Integer> entry) -> {
        
        System.out.print("key = " + entry.getKey());
        System.out.println(", value = " + entry.getValue());
    });
    执行结果：
    key = 小明, value = 1
    key = 小红, value = 2
    key = 小张, value = 3

但是在idea编译器中，编译器会给出警告，提示说该写法可以简化，简化后的写法和lambda表达式一致：

map1.forEach((key, value) -> {
        
        System.out.print("key = " + key);
        System.out.println(", value = " + value);
    });

#### 总结——简洁又好用的遍历方式 ####

**①for-each + entrySet()遍历**

HashMap<String, Integer> map1 = new HashMap<>();
    map1.put("小明", 1);
    map1.put("小红", 2);
    map1.put("小张", 3);
    
    //for-each + entrySet()遍历
    for (Map.Entry<String, Integer> entry : map1.entrySet()) {
        
        System.out.print("key = " + entry.getKey());
        System.out.println(", value = " + entry.getValue());
    }

**②lambda表达式遍历**

HashMap<String, Integer> map1 = new HashMap<>();
    map1.put("小明", 1);
    map1.put("小红", 2);
    map1.put("小张", 3);
    
    //lambda表达式遍历
    map1.forEach((key, value)->{
        
        System.out.print("key = " + key);
        System.out.println(", value = " + value);
    });

鸣谢：https://blog.csdn.net/qq\_52430605/article/details/132159145

[789ed0f56699450eab40b3c0eca19ba6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/94aebad402bf4febba9b5233833ac3dd.png
[9eb60b7b4e804d1ab6162fa3226b39b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/2cae2899c71f403eb57338f3eb7ee581.png
[7f6058ab6c3e4628979908d67d63720b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/d9040eeaa1e64fd3bbbabc62063d64ee.png
[7e2735fd4d094d1096e7139524bd0c1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/fc2e735a511a445a9ac8bb077a84a121.png
[9a4d246860cb4ea7a251985c3549f023.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/039f8664e0684e80960f258132215762.png
[35c06b594d5542598186c1091ed04030.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/10634ce0cee34654bd47015827460036.png
[c8b872ae46a047f4ab9d82e25beb674e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/d5b83b8a0a82473aa16bcdb0e18d20ac.png
[ba95828a8f884bc9832151ed6176d936.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/04e050a620a845cea26947ebb42c4480.png