Java中遍历HashMap的5种方式

Java
124
0
0
2024-08-21
Spring Boot 干预优化+加快启动时间（干货典藏版）
上一篇
什么是Spring Security？具有哪些功能？
下一篇
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时，需要注意一些关键点，以确保代码的正确性和效率。以下是一些重要的注意事项，以及相应的案例源码说明。

避免在迭代过程中修改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方法
            }
        }
    }
}

使用并发安全的遍历方式

如果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()) {
            // 即使在多线程环境下，这里的遍历也是安全的
        }
    }
}

注意键值对的类型转换

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

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

考虑性能影响

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

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    // 这种遍历方式通常比使用values()或keySet()更高效
}
Spring Boot 干预优化+加快启动时间（干货典藏版）
上一篇
什么是Spring Security？具有哪些功能？
下一篇