原文： https://www.programiz.com/java-programming/hashmap

在本教程中，我们将借助示例学习 Java HashMap类及其方法。

Java 集合框架的HashMap类提供Map接口的哈希表实现。

创建一个HashMap

为了创建哈希映射，我们必须首先导入java.util.HashMap包。 导入包后，就可以使用 Java 创建哈希映射。

  1. // HashMap creation with 8 capacity and 0.6 load factor
  2. HashMap<Key, Value> numbers = new HashMap<>(8, 0.6f);

在上面的代码中，我们创建了一个名为number的哈希映射。

这里，

  • Key - 用于关联映射中每个元素（值）的唯一标识符
  • Value - 映射中与按键相关联的元素

注意部分new HashMap<>(8, 0.6)。 在此，第一个参数是capcity，第二个参数是loadFactor。

  • capcity-此哈希映射的容量为 8。意味着，它可以存储 8 个条目。
  • loadFactor -此哈希映射的负载因子为 0.6。 这意味着，只要我们的哈希表填充了 60%，条目就会移到新哈希表中，其大小是原始哈希表的两倍。

默认容量和负载系数

创建哈希表而不定义其容量和负载因子是可能的。 例如，

  1. // HashMap with default capacity and load factor
  2. HashMap<Key, Value> numbers1 = new HashMap<>();

默认，

  • 哈希映射的容量将为 16
  • 负载系数将为 0.75

从其他映射创建HashMap

这是我们如何创建包含其他映射的所有元素的哈希映射的方法。

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         // Creating a hashmap of even numbers
  6.         HashMap<String, Integer> evenNumbers = new HashMap<>();
  7.         evenNumbers.put("Two", 2);
  8.         evenNumbers.put("Four", 4);
  9.         System.out.println("HashMap1: " + evenNumbers);
  11.         // Creating a hash map from other hashmap
  12.         HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
  13.         numbers.put("Three", 3);
  14.         System.out.println("HashMap2: " + numbers);
  15.     }
  16. }

输出

  1. HashMap1: {Four=4, Two=2}
  2. HashMap2: {Two=2, Three=3, Four=4}

HashMap的方法

HashMap类提供了各种方法，可让我们在映射上执行各种操作。

将元素插入HashMap

  • put() - 将指定的键/值映射插入到映射中
  • putAll() - 将指定映射中的所有条目插入此映射中
  • putIfAbsent() - 如果映射中不存在指定的键，则将指定的键/值映射插入到映射中

例如，

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         // Creating HashMap of even numbers
  6.         HashMap<String, Integer> evenNumbers = new HashMap<>();
  8.         // Using put()
  9.         evenNumbers.put("Two", 2);
  10.         evenNumbers.put("Four", 4);
  12.         // Using putIfAbsent()
  13.         evenNumbers.putIfAbsent("Six", 6);
  14.         System.out.println("HashMap of even numbers: " + evenNumbers);
  16.         //Creating HashMap of numbers
  17.         HashMap<String, Integer> numbers = new HashMap<>();
  18.         numbers.put("One", 1);
  20.         // Using putAll()
  21.         numbers.putAll(evenNumbers);
  22.         System.out.println("HashMap of numbers: " + numbers);
  23.     }
  24. }

输出：

  1. HashMap of even numbers: {Six=6, Four=4, Two=2}
  2. HashMap of numbers: {Six=6, One=1, Four=4, Two=2}

访问HashMap元素

1.使用entrySet()，keySet()和values()

  • entrySet() - 返回一组所有键/值映射的映射
  • keySet() - 返回映射的所有键的集合
  • values() - 返回一组所有映射值

例如：

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         HashMap<String, Integer> numbers = new HashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("HashMap: " + numbers);
  12.         // Using entrySet()
  13.         System.out.println("Key/Value mappings: " + numbers.entrySet());
  15.         // Using keySet()
  16.         System.out.println("Keys: " + numbers.keySet());
  18.         // Using values()
  19.         System.out.println("Values: " + numbers.values());
  20.     }
  21. }

输出：

  1. HashMap: {One=1, Two=2, Three=3}
  2. Key/Value mappings: [One=1, Two=2, Three=3]
  3. Keys: [One, Two, Three]
  4. Values: [1, 2, 3]

2.使用get()和getOrDefault()

  • get() - 返回与指定键关联的值。 如果找不到键，则返回null。
  • getOrDefault() - 返回与指定键关联的值。 如果找不到键，则返回指定的默认值。

例如：

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         HashMap<String, Integer> numbers = new HashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("HashMap: " + numbers);
  12.         // Using get()
  13.         int value1 = numbers.get("Three");
  14.         System.out.println("Returned Number: " + value1);
  16.         // Using getOrDefault()
  17.         int value2 = numbers.getOrDefault("Five", 5);
  18.         System.out.println("Returned Number: " + value2);
  19.     }
  20. }

输出：

  1. HashMap: {One=1, Two=2, Three=3}
  2. Returned Number: 3
  3. Returned Number: 5

删除元素

  • remove(key) - 返回并从映射中删除与指定键关联的条目
  • remove(key, value) - 仅当指定键映射到指定值并返回布尔值时，才从映射中删除条目

例如：

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         HashMap<String, Integer> numbers = new HashMap<>();
  7.         numbers.put("One", 1);
  8.         numbers.put("Two", 2);
  9.         numbers.put("Three", 3);
  10.         System.out.println("HashMap: " + numbers);
  12.         // remove method with single parameter
  13.         int value = numbers.remove("Two");
  14.         System.out.println("Removed value: " + value);
  16.         // remove method with two parameters
  17.         boolean result = numbers.remove("Three", 3);
  18.         System.out.println("Is the entry Three removed? " + result);
  20.         System.out.println("Updated HashMap: " + numbers);
  21.     }
  22. }

输出：

  1. HashMap: {One=1, Two=2, Three=3}
  2. Removed value: 2
  3. Is the entry Three removed? True
  4. Updated HashMap: {One=1}

替换元素

  • replace(key, value) - 用新的value替换与指定的key相关的值
  • replace(key, old, new) - 仅当old值已与指定的key关联时，才用new值替换old值。
  • replaceAll(function) - 用指定的function的结果替换映射的每个值

例如：

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         HashMap<String, Integer> numbers = new HashMap<>();
  7.         numbers.put("First", 1);
  8.         numbers.put("Second", 2);
  9.         numbers.put("Third", 3);
  10.         System.out.println("Original HashMap: " + numbers);
  12.         // Using replace()
  13.         numbers.replace("Second", 22);
  14.         numbers.replace("Third", 3, 33);
  15.         System.out.println("HashMap using replace(): " + numbers);
  17.         // Using replaceAll()
  18.         numbers.replaceAll((key, oldValue) -> oldValue + 2);
  19.         System.out.println("HashMap using replaceAll(): " + numbers);
  20.     }
  21. }

输出：

  1. Original HashMap: {Second=2, Third=3, First=1}
  2. HashMap using replace: {Second=22, Third=33, First=1}
  3. HashMap using replaceAll: {Second=24, Third=35, First=3}

在上述程序中，声明

  1. numbers.replaceAll((key, oldValue) -> oldValue + 2);

在此，该方法访问映射的所有条目。 然后，它将所有值替换为 lambda 表达式提供的新值。

重新计算值

1.使用compute()方法

  • compute() - 使用指定的函数计算新值。 然后，它将计算的值与指定的键相关联。
  • computeIfAbsent() - 如果指定的键未映射到任何值，则该方法将使用指定的函数计算新值。 然后，它将新值与键关联。
  • computeIfPresent() - 如果指定的键已经映射到任何值，则此方法将使用指定的函数计算新值。 然后，它将新值与键关联。

例如：

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         HashMap<String, Integer> numbers = new HashMap<>();
  7.         numbers.put("First", 1);
  8.         numbers.put("Second", 2);
  9.         System.out.println("Original HashMap: " + numbers);
  11.         // Using compute()
  12.         numbers.compute("First", (key, oldValue) -> oldValue + 2);
  13.         numbers.compute("Second", (key, oldValue) -> oldValue + 1);
  14.         System.out.println("HashMap using compute(): " + numbers);
  16.         // Using computeIfAbsent()
  17.         numbers.computeIfAbsent("Three", key -> 5);
  18.         System.out.println("HashMap using computeIfAbsent(): " + numbers);
  20.         // Using computeIfPresent()
  21.         numbers.computeIfPresent("Second", (key, oldValue) -> oldValue * 2);
  22.         System.out.println("HashMap using computeIfPresent(): " + numbers);
  23.     }
  24. }

输出：

  1. Original HashMap: {Second=2, First=1}
  2. HashMap using compute(): {Second=3, First=3}
  3. HashMap using computeIfAbsent(): {Second=3 First=3, Three=5}
  4. HashMap using computeIfPresent(): {Second=6, First=3, three=5}

在上面的示例中，我们使用compute()方法重新计算了映射的值。

在这里，我们使用 lambda 表达式作为方法参数来重新计算值。

2.使用merge()方法

如果指定的键尚未关联，则merge()方法会将指定的值关联到指定的键。

但是，如果指定的键已经与某个值相关联，它将把新的指定值与现有的旧值合并。 例如，

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  6.         HashMap<String, Integer> numbers = new HashMap<>();
  7.         numbers.put("First", 1);
  8.         numbers.put("Second", 2);
  9.         System.out.println("Original HashMap: " + numbers);
  11.         // Using merge() Method
  12.         numbers.merge("First", 4, (oldValue, newValue) -> oldValue + newValue);
  13.         System.out.println("New HashMap: " + numbers);
  14.     }
  15. }

输出：

  1. Original HashMap: {Second=2, First=1}
  2. New HashMap: {Second=2, First=5}

在上面的示例中，merge()方法采用 3 个参数：key，newValue和 lambda 表达式（用于计算新的合并值）。

HashMap的其他方法

方法 描述
clear() 从映射中删除所有条目
containsKey() 检查映射是否包含指定的键并返回布尔值
containsValue() 检查映射是否包含指定的值并返回布尔值
size() 返回映射的大小
isEmpty() 检查映射是否为空并返回布尔值

迭代HashMap

在HashMap中，我们可以

  • 遍历其键
  • 遍历其值
  • 遍历其键/值

1.使用forEach循环

  1. import java.util.HashMap;
  2. import java.util.Map.Entry;
  4. class Main {
  5.     public static void main(String[] args) {
  7.         // Creating a HashMap
  8.         HashMap<String, Integer> numbers = new HashMap<>();
  9.         numbers.put("One", 1);
  10.         numbers.put("Two", 2);
  11.         numbers.put("Three", 3);
  12.         System.out.println("HashMap: " + numbers);
  14.         // Accessing the key/value pair
  15.         System.out.print("Entries: ");
  16.         for(Entry<String, Integer> entry: numbers.entrySet()) {
  17.             System.out.print(entry);
  18.             System.out.print(", ");
  19.         }
  21.         // Accessing the key
  22.         System.out.print("\nKeys: ");
  23.         for(String key: numbers.keySet()) {
  24.             System.out.print(key);
  25.             System.out.print(", ");
  26.         }
  28.         // Accessing the value
  29.         System.out.print("\nValues: ");
  30.         for(Integer value: numbers.values()) {
  31.             System.out.print(value);
  32.             System.out.print(", ");
  33.         }
  34.     }
  35. }

输出：

  1. HashMap: {One=1, Two=2, Three=3}
  2. Entries: One=1, Two=2, Three=3
  3. Keys: One, Two, Three,
  4. Values: 1, 2, ,3,

在上面的程序中，请注意，我们已经导入了java.util.Map.Entry包。 在这里，Map.Entry是Map接口的嵌套类。

该嵌套类返回映射的视图（元素）。

2.使用iterator()方法

也可以使用iterator()方法迭代HashMap。 为了使用此方法，我们必须导入java.util.Iterator包。

  1. import java.util.HashMap;
  2. import java.util.Iterator;
  3. import java.util.Map.Entry;
  5. class Main {
  6.     public static void main(String[] args) {
  7.         // Creating a HashMap
  8.         HashMap<String, Integer> numbers = new HashMap<>();
  9.         numbers.put("One", 1);
  10.         numbers.put("Two", 2);
  11.         numbers.put("Three", 3);
  12.         System.out.println("HashMap: " + numbers);
  14.         // Creating an object of Iterator
  15.         Iterator<Entry<String, Integer>> iterate1 = numbers.entrySet().iterator();
  17.         // Accessing the Key/Value pair
  18.         System.out.print("Entries: ");
  19.         while(iterate1.hasNext()) {
  20.             System.out.print(iterate1.next());
  21.             System.out.print(", ");
  22.         }
  24.         // Accessing the key
  25.         Iterator<String> iterate2 = numbers.keySet().iterator();
  26.         System.out.print("\nKeys: ");
  27.         while(iterate2.hasNext()) {
  28.             System.out.print(iterate2.next());
  29.             System.out.print(", ");
  30.         }
  32.         // Accessing the value
  33.         Iterator<Integer> iterate3 = numbers.values().iterator();
  34.          System.out.print("\nValues: ");
  35.         while(iterate3.hasNext()) {
  36.             System.out.print(iterate3.next());
  37.             System.out.print(", ");
  38.         }
  39.     }
  40. }

输出：

  1. HashMap: {One=1, Two=2, Three=3}
  2. Entries: One=1, Two=2, Three=3
  3. Keys: One, Two, Three,
  4. Values: 1, 2, 3,

在上面的程序中， note that we have imported the java.util.Map.Entry package. Here, Map.Entry is the nested class of the Map interface.

This nested class returns a view (elements) of the map.