Java中遍历HashMap的5种方式

最新推荐文章于 2024-08-28 00:39:43 发布
最新推荐文章于 2024-08-28 00:39:43 发布
阅读量2.5k 收藏 35
点赞数 25
分类专栏： 王也《Java》 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Java_WuDG/article/details/137821683
版权
本文详细介绍了Java中遍历HashMap的5种方法，包括for-each循环、Iterator迭代器、StreamAPI、Lambda表达式和Map.Entry集合，同时强调了遍历过程中的注意事项，如避免在迭代中修改HashMap和使用线程安全的遍历方式。
摘要由CSDN通过智能技术生成

hi，我是程序员王也，一个资深Java开发工程师，平时十分热衷于技术副业变现和各种搞钱项目的程序员~，如果你也是，可以一起交流交流。

今天我们来一起聊聊Java中遍历HashMap的5种方式。

在这里插入图片描述

HashMap基础

HashMap是Java中最常用的集合之一，它实现了Map接口并提供了键值对的映射。在Java中，HashMap是一个非同步的类，它的主要目的是为了快速的数据访问和搜索。

  1. 数据结构和工作原理

    HashMap基于哈希表的工作原理。它使用键（key）的哈希码（hash code）来计算存储位置，从而快速定位值（value）。当两个不同的键具有相同的哈希码时，会发生哈希冲突。HashMap通过链表或红黑树来解决哈希冲突，这取决于Java版本和哈希表的负载因子。

  2. 键值对特性

    HashMap中的键和值都可以是null。每个键只能映射到一个值，但不同的键可以映射到相同的值。HashMap不保证键的顺序，这意味着遍历顺序可能会在不同的迭代中发生变化。

  3. 性能考虑

    HashMap的性能主要取决于哈希函数的质量和键的分布。一个好的哈希函数可以将键均匀分布在哈希表中，从而减少哈希冲突和提高性能。此外，HashMap的初始容量和加载因子也会影响性能。默认情况下，HashMap的初始容量为16，加载因子为0.75。当哈希表的容量达到加载因子阈值时，HashMap会自动进行扩容，这可能会引起短暂的性能下降。

案例源码说明

以下是一个简单的HashMap使用示例：

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例
        Map<String, Integer> map = new HashMap<>();

        // 向HashMap中添加键值对
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);

        // 访问和打印HashMap中的元素
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

在这个例子中，我们创建了一个HashMap实例，并添加了一些键值对。然后我们使用entrySet()方法和for-each循环来遍历HashMap并打印出所有的键和值。

以下是“Java中遍历HashMap的5种方式”技术文章的第三小节“方式一：使用for-each循环”部分的内容：

方式一：使用for-each循环

使用for-each循环是遍历HashMap中最简单的方式之一。这种方式简洁且易于阅读，适用于Java 5及以上版本。当你使用for-each循环时，你实际上是在遍历HashMap的entrySet。

案例源码说明

以下是一个使用for-each循环遍历HashMap的示例：

import java.util.HashMap;
import java.util.Map;

public class HashMapTraversalForEachExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例并添加一些键值对
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 10);
        map.put("banana", 20);
        map.put("cherry", 30);

        // 使用for-each循环遍历HashMap
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

在这个例子中，我们首先创建了一个HashMap并填充了一些数据。然后，我们使用for-each循环来遍历HashMap的entrySet。在每次迭代中，我们通过getKey()和getValue()方法来获取键和值，并打印它们。

注意事项

  • 使用for-each循环时，你不能在迭代过程中修改HashMap的大小，即不能添加或删除元素。如果你需要在迭代过程中修改HashMap，请使用Iterator。
  • for-each循环背后的机制是使用协变通配符（covariant type wildcards），它要求集合中的元素类型与循环变量的类型相匹配。这意味着你不能将不同类型的对象放入同一个HashMap中，除非你使用泛型。
    以下是“Java中遍历HashMap的5种方式”技术文章的第四小节“方式二：使用Iterator迭代器”部分的内容：

方式二：使用Iterator迭代器

Iterator迭代器是Java集合框架中提供的一种通用的遍历方式。使用Iterator可以遍历几乎所有的集合类型，包括HashMap。与for-each循环相比，Iterator提供了更多的控制能力，例如在迭代过程中可以安全地删除元素。

案例源码说明

以下是一个使用Iterator遍历HashMap的示例：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class HashMapTraversalIteratorExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例并添加一些键值对
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 10);
        map.put("banana", 20);
        map.put("cherry", 30);

        // 获取HashMap的迭代器
        Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();

        // 使用while循环和Iterator遍历HashMap
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> entry = iterator.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

在这个例子中，我们首先创建了一个HashMap并填充了一些数据。然后，我们通过entrySet().iterator()方法获取了HashMap的迭代器。使用while循环和Iterator的hasNext()方法，我们可以遍历HashMap中的所有键值对。在每次迭代中，我们通过next()方法获取当前的键值对，并打印出键和值。

注意事项

  • 使用Iterator时，如果需要在迭代过程中删除元素，可以调用iterator.remove()方法。这将删除当前迭代到的元素，并且不会抛出ConcurrentModificationException异常。
  • Iterator提供了对集合元素的弱一致性遍历。这意味着在迭代过程中，如果集合的结构发生了变化（例如添加或删除了元素），Iterator可能会抛出ConcurrentModificationException异常。
  • 在Java 8及以上版本中，你还可以使用removeIf()方法来简化集合的删除操作。这个方法接受一个Predicate作为参数，并删除所有满足该谓词的元素。

以下是“Java中遍历HashMap的5种方式”技术文章的第五小节“方式三：使用Stream API”部分的内容：

方式三：使用Stream API

Java 8引入了Stream API，它提供了一种新的集合处理方式，允许你以声明式的方式处理集合数据。使用Stream API，你可以轻松地对HashMap中的键值对进行遍历、筛选、转换和聚合操作。

案例源码说明

以下是一个使用Stream API遍历HashMap的示例：

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class HashMapTraversalStreamExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例并添加一些键值对
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 10);
        map.put("banana", 20);
        map.put("cherry", 30);

        // 使用Stream API遍历HashMap的键值对
        map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));

        // 使用Stream API筛选出值大于15的键值对
        map.entrySet().stream()
              .filter(entry -> entry.getValue() > 15)
              .forEach(entry -> System.out.println("Filtered Key: " + entry.getKey() + ", Value: " + entry.getValue()));

        // 使用Stream API将所有值转换为字符串，并收集到一个列表中
        List<String> valuesAsString = map.values().stream()
                                              .map(Object::toString)
                                              .collect(Collectors.toList());
        System.out.println("Values as String: " + valuesAsString);

        // 使用Stream API计算所有值的总和
        int sum = map.values().stream()
                       .mapToInt(Integer::intValue)
                       .sum();
        System.out.println("Sum of Values: " + sum);
    }
}

在这个例子中，我们首先创建了一个HashMap并填充了一些数据。然后，我们使用forEach方法直接在HashMap上进行遍历和打印。接着，我们使用stream()方法和filter()方法筛选出值大于15的键值对，并进行打印。此外，我们还展示了如何使用map()方法和collect()方法将值转换为字符串列表，以及如何使用mapToInt()方法和sum()方法计算所有值的总和。

注意事项

  • Stream API的链式调用使得代码更加简洁和易于理解，但是它可能会牺牲一些性能，特别是在大数据集上进行操作时。
  • 当使用Stream API处理HashMap时，应该注意内联操作（如filter(), map()等）和终端操作（如collect(), forEach()等）的使用顺序和效率。
  • 由于HashMap不是线程安全的，因此在并发环境下使用Stream API处理HashMap时，应该确保不会在迭代过程中修改HashMap。

以下是“Java中遍历HashMap的5种方式”技术文章的第六小节“方式四：使用Lambda表达式和Stream API”部分的内容：

方式四：使用Lambda表达式和Stream API

结合Lambda表达式和Stream API可以进一步简化对HashMap的遍历和操作。Lambda表达式提供了一种更加简洁的方式来实现函数式接口，而Stream API则允许对数据流进行复杂的操作。这种方法特别适合于需要对HashMap中的元素进行复杂的转换和聚合的场景。

案例源码说明

以下是一个使用Lambda表达式和Stream API遍历HashMap的示例：

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class HashMapTraversalLambdaExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例并添加一些键值对
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 10);
        map.put("banana", 20);
        map.put("cherry", 30);

        // 使用Lambda表达式和Stream API遍历和打印所有键值对
        map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));

        // 使用Stream API和Lambda表达式筛选出值大于15的键值对
        map.entrySet().stream()
              .filter(entry -> entry.getValue() > 15)
              .forEach(entry -> System.out.println("Filtered Key: " + entry.getKey() + ", Value: " + entry.getValue()));

        // 使用Stream API和Lambda表达式将所有值转换为字符串，并收集到一个列表中
        List<String> valuesAsString = map.values().stream()
                                              .map(Object::toString)
                                              .collect(Collectors.toList());
        System.out.println("Values as String: " + valuesAsString);

        // 使用Stream API和Lambda表达式计算所有值的总和
        int sum = map.values().stream()
                       .mapToInt(Integer::intValue)
                       .sum();
        System.out.println("Sum of Values: " + sum);

        // 使用Stream API和Lambda表达式获取最大值
        Optional<Integer> max = map.values().stream()
                                         .max(Comparator.naturalOrder());
        max.ifPresent(value -> System.out.println("Max Value: " + value));

        // 使用Stream API和Lambda表达式转换键值对为自定义对象的列表
        List<Fruit> fruits = map.entrySet().stream()
                                 .map(entry -> new Fruit(entry.getKey(), entry.getValue()))
                                 .collect(Collectors.toList());
        fruits.forEach(fruit -> System.out.println(fruit));
    }

    // 自定义对象，用于演示对象的转换
    public static class Fruit {
        private final String name;
        private final int calories;

        public Fruit(String name, int calories) {
            this.name = name;
            this.calories = calories;
        }

        public String getName() {
            return name;
        }

        public int getCalories() {
            return calories;
        }

        @Override
        public String toString() {
            return "Fruit{" +
                   "name='" + name + '\'' +
                   ", calories=" + calories +
                   '}';
        }
    }
}

在这个例子中，我们首先创建了一个HashMap并填充了一些数据。然后，我们使用Lambda表达式和Stream API进行了一系列操作，包括遍历打印、筛选、转换、聚合和对象转换。这些操作展示了Lambda表达式和Stream API在处理HashMap时的强大和灵活性。

注意事项

  • 当使用Lambda表达式时，应该注意变量的捕获和作用域。在Lambda表达式中使用的外部变量必须是final或effectively final。
  • Stream API的操作通常分为三个部分：源数据的获取、中间操作的链式调用和终端操作的结果收集。开发者应该根据实际需求选择合适的中间操作和终端操作。
  • 在进行复杂的转换和聚合操作时，应该考虑性能和内存消耗，尤其是在处理大数据集时。

以下是“Java中遍历HashMap的5种方式”技术文章的第七小节“方式五：使用Map.Entry集合”部分的内容：

方式五：使用Map.Entry集合

Map.Entry是java.util.Map接口中的一个内部接口，它代表了Map中的一个键值对。使用Map.Entry集合可以让我们直接访问HashMap中的每个条目，而不需要通过迭代器或流API。这种方式提供了对HashMap中数据的直接访问，使得我们可以轻松地操作键和值。

案例源码说明

以下是一个使用Map.Entry集合遍历HashMap的示例：

import java.util.HashMap;
import java.util.Map;

public class HashMapTraversalMapEntryExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例并添加一些键值对
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 10);
        map.put("banana", 20);
        map.put("cherry", 30);

        // 使用Map.Entry集合遍历HashMap
        for (Object entry : map.entrySet()) {
            Map.Entry<String, Integer> entryObj = (Map.Entry<String, Integer>) entry;
            String key = entryObj.getKey();
            Integer value = entryObj.getType();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

在这个例子中，我们首先创建了一个HashMap并填充了一些数据。然后，我们使用entrySet()方法获取了HashMap中的所有条目，并使用普通的for循环来遍历它们。在每次迭代中，我们将Object类型的entry强制转换为Map.Entry<String, Integer>类型，并使用getKey()和getValue()方法来获取键和值。

注意事项

  • 在使用Map.Entry集合时，需要注意类型转换。由于entrySet()方法返回的是Set<Map.Entry>类型，其中Entry对象是Object类型的，因此我们需要将其转换为正确的泛型类型。
  • 使用Map.Entry集合时，你可以直接访问键和值，而不需要使用Iterator或Stream。这使得代码更加直观和易于理解。
  • 与其他遍历方式相比，使用Map.Entry集合不会提供流式处理的能力，但它可以用于需要直接访问键值对的简单遍历场景。

以下是“Java中遍历HashMap的5种方式”技术文章的第八小节“遍历时的注意事项”部分的内容：

遍历时的注意事项

在遍历HashMap时，需要注意一些关键点，以确保代码的正确性和效率。以下是一些重要的注意事项，以及相应的案例源码说明。

  1. 避免在迭代过程中修改HashMap

    在遍历HashMap时，直接添加或删除元素可能会导致ConcurrentModificationException异常。如果需要在迭代过程中修改HashMap，应该使用迭代器的remove()方法。

    import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class HashMapIterationExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 10);
        map.put("banana", 20);
        map.put("cherry", 30);

        Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> entry = iterator.next();
            if (entry.getValue() > 20) {
                iterator.remove(); // 正确方式：使用迭代器的remove方法
            }
        }
    }
}

  2. 使用并发安全的遍历方式

    如果HashMap将在多线程环境中被访问，应确保使用线程安全的遍历方式。对于非线程安全的遍历，可以考虑使用ConcurrentHashMap。

    import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapIterationExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        concurrentMap.put("apple", 10);
        concurrentMap.put("banana", 20);
        concurrentMap.put("cherry", 30);

        for (Map.Entry<String, Integer> entry : concurrentMap.entrySet()) {
            // 即使在多线程环境下，这里的遍历也是安全的
        }
    }
}

  3. 注意键值对的类型转换

    在使用Map.Entry集合遍历时，需要进行适当的类型转换，以确保类型安全。

    for (Object entryObj : map.entrySet()) {
    Map.Entry<String, Integer> entry = (Map.Entry<String, Integer>) entryObj;
    // 现在可以安全地使用entry的getKey()和getValue()方法
}

  4. 考虑性能影响

    某些遍历方式可能比其他方式更高效，尤其是在处理大型数据集时。例如，使用entrySet()遍历时，不需要额外的类型转换，通常比使用values()和keySet()更快。

    for (Map.Entry<String, Integer> entry : map.entrySet()) {
    // 这种遍历方式通常比使用values()或keySet()更高效
}
程序员王也
关注
专栏目录
Java性能优化-HashMap遍历的7种方式及性能测试对比
BADAO_LIUMANG_QIZHI的博客
07-11 1167
参考以上性能测试工具的使用。下面针对Java中对HashMap的7种遍历方式做性能测试。
Java之hashMap遍历方式
m0_67401545的博客
06-05 221
在java开发中，hashMap是非常重要的容器类，存储的是键值对(key，value)。 HashMap继承AbstractMap，实现了Map、Cloneable、Serializable接口，非线程安全类，但是效率高。HashMap允许null健和null值，允许value重复，但不允许key重复。HashMap有两个参数影响其性能，初始容量和加载因子，当哈希表中的条目数超出加载因子与当前容量的乘积时，要对哈希表进行refresh操作，重建内部数据结构，容量扩大为之前的两倍，加载因子默认值为0.75。
转]Java中HashMap遍历的两种方式
qq237484840的专栏
12-08 382
第一种:　　Map map = new HashMap(); 　　Iterator iter = map.entrySet().iterator(); 　　while (iter.hasNext()) { 　　Map.Entry entry = (Map.Entry) iter.next(); 　　Object key = entry.getKey(); 　　Object val = entry.
HashMap的7种遍历方式
2402_85406406的博客
08-28 682
HashMap的遍历方式有七种？经常用的感觉就两种，一种用迭代器，一种ForEach(增强型for循环)，感觉就没了。网上查了一下，还真有其他的。今天总结一下。
java中遍历HashMap的方法
dengwenmang7886的博客
11-09 145
Java中，通常有两种遍历HashMap的方法，如下： import java.util.*; public class MapTest { static HashMap<String, Integer> hashMap = new HashMap<String, Integer>(); public static void main(Str...
Java Map遍历的各种方法
梁健的博客
08-18 286
//最常规的一种遍历方法，最常规就是最常用的，虽然不复杂，但很重要，这是我们最熟悉的，就不多说了！！    public static void work(Map&lt;String, Student&gt; map) {        Collection&lt;Student&gt; c = map.values();        Iterator it = c.iterator();   ...
Java5种遍历HashMap数据的写法
08-19
Java5种遍历HashMap数据的写法 Java语言中，HashMap是一种常用的数据结构，用于存储键值对形式的数据。然而，在实际开发中，我们经常需要遍历HashMap中的数据以实现某些功能。下面将介绍五种遍历HashMap数据的写法...
java遍历HashMap简单的方法
09-03
在Java编程中，HashMap是一种常用的集合类，...总的来说，遍历HashMap是Java开发中的基本操作，理解并掌握这些方法对于提升代码效率和可读性至关重要。希望本文的实例解析能对你在Java程序设计中处理HashMap有所帮助。
java中遍历HashMap的几种方法
qq_24210431的博客
03-17 1095
一、使用foreach遍历 1.使用HashMap的.entrySet()方法返回它包含的所有条目的集合，foreach遍历条目集合得到一个个条目Entry<K,V> import java.lang.Integer; import java.lang.Character; import java.util.HashMap; import java.util.Map.Entry; pu...
java中hashmap遍历
白小白的小白的博客
05-25 3698
java中hashmap遍历有两种方法，第一种就是将所有的key放到set中，然后通过遍历set通过key来获取value，可以选择使用迭代器遍历也可以使用增强for来遍历，第二种可以使用entryset来循环，推荐使用entryset，因为entry里面放的是key和value，所以效率更快 // hashmap操作(key value, key不可以重复, 无序)key 经过hash加密，并且equal对比来确定其内存地址 System.out.println("hashmap操作===
Java遍历HashMap
a402498234的博客
02-27 630
Java如何遍历HashMap
Java中HashMap遍历的两种方式
weixin_33733810的博客
11-02 195
转]Java中HashMap遍历的两种方式原文地址: http://www.javaweb.cc/language/java/032291.shtml第一种:　　Map map = new HashMap();　　Iterator iter = map.entrySet().iterator();　　while (iter.hasNext()) {　　Map.Entry entry = (Ma...
遍历hashmap ---java
atpx309391907的专栏
02-28 457
一. 　　HashMap staff = new HashMap(); 　　添加关键字值对，自己写遍历 　　Set entries = staff.entrySet(); 　　Iterator iter = entries.iterator(); 　　while(iter.hasNext()) 　　{ 　　 Map.Entry entry = (Map.E
Java 基础——HashMap 遍历方式
代码星辰的博客
03-30 2313
本文介绍了 HashMap 几种常用的遍历方式。
如何遍历map对象
cxmscb的博客
03-02 729
HashMap遍历在Java中有多种遍历HashMAp的方法。让我们回顾一下最常见的方法和它们各自的优缺点。由于所有的Map都实现了Map接口，所以接下来方法适用于所有Map（如：HaspMap，TreeMap,LinkedMap,HashTable,etc）方法#1 使用For-Each迭代entries这是最常见的方法，并在大多数情况下更可取的。当你在循环中需要使用Map的键和值时，就可以使用这
java如何遍历HashMap
最新发布
09-09
在Java中，遍历`HashMap`可以通过多种方式实现，以下是一些常见的方法： 1. 使用`entrySet()`方法遍历： `entrySet()`方法返回`Map.Entry`集的视图集合，可以直接遍历得到键值对。 ```java HashMap<String, Integer> map = new HashMap<>(); for(Map.Entry<String, Integer> entry : map.entrySet()) { String key = entry.getKey(); Integer value = entry.getValue(); // 处理键值对 } ``` 2. 使用`keySet()`方法遍历键，再根据键获取值： `keySet()`方法返回所有键的集合视图，遍历这个集合并使用键来获取对应的值。 ```java for(String key : map.keySet()) { Integer value = map.get(key); // 处理键和值 } ``` 3. 使用`values()`方法遍历值： `values()`方法返回所有值的集合视图，如果只需要遍历值，则可以使用这个方法。 ```java for(Integer value : map.values()) { // 处理值 } ``` 4. 使用增强型for循环与`Map.Entry`结合： Java 5及以上版本可以使用增强型for循环结合Map.Entry实现更简洁的遍历。 ```java for(Map.Entry<String, Integer> entry : map.entrySet()) { String key = entry.getKey(); Integer value = entry.getValue(); // 处理键值对 } ``` 5. 使用Java 8的Stream API遍历： Java 8引入了Stream API，可以提供更加灵活的遍历方式。 ```java map.forEach((key, value) -> { // 处理键值对 }); ```
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值