{% raw %}

Java HashMap教程

原文：http://zetcode.com/java/hashmap/

Java HashMap教程显示了如何使用 Java HashMap集合。

Java HashMap

HashMap是一个存储键值对的容器。 每个键与一个值关联。 HashMap中的键必须唯一。 HashMap在其他编程语言中称为关联数组或词典。 HashMaps占用更多内存，因为每个值还有一个键。 删除和插入操作需要固定的时间。 HashMaps可以存储空值。

HashMaps不维持秩序。

Map.Entry表示HashMap中的键/值对。 HashMap的entrySet()返回包含在映射中的映射的Set视图。 使用keySet()方法检索一组键。

Java HashMap层次结构

HashMap扩展了AbstractMap并实现了Map。 Map提供了包括get()，put()，size()或isEmpty()的方法签名。

Java HashMap构造器

  • HashMap()-构造一个空的HashMap()，其默认初始容量（16）和默认负载因子（0.75）。
  • HashMap(int initialCapacity)-构造一个空的HashMap()，具有给定的初始容量和默认的负载系数（0.75）。
  • HashMap(int initialCapacity, float loadFactor)-使用给定的初始容量和负载因子构造一个空的HashMap()。
  • HashMap(Map<? extends K,? extends V> m) —构造一个新的HashMap()，其映射与给定的Map相同。

K是映射键的类型，V是映射值的类型。

Java HashMap方法

下表提供了几种HashMap方法。

修饰符和类型 方法 描述
void clear() 从映射中删除所有映射。
Object clone() 返回HashMap实例的浅表副本：键和值本身不会被克隆。
boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回true。
Set<Map.Entry<K, V>> entrySet() 返回此映射中包含的映射的Set视图。
boolean isEmpty() 如果此映射为空，则返回true。
Set<K> keySet() 返回此映射中包含的键的Set视图。
V put(K key, V value) 向映射添加新的映射。
V remove(Objec key) 如果存在，则从此映射中删除指定键的映射。
V get(Object key) 返回指定键所映射到的值；如果此映射不包含键的映射关系，则返回null。
void forEach(BiConsumer<? super K, ? super V> action) 在此映射中为每个条目执行给定的操作，直到所有条目都已处理或该操作引发异常。
V replace(K key, V value) 仅当当前映射到某个值时，才替换指定键的条目。
int size() 返回此映射中的键值映射数。
Collection<V> values() 返回此映射中包含的值的Collection视图。

在本教程中，我们将使用其中的几种方法。

Java HashMap创建

用new关键字创建HashMap。

  1. Map<String, String> capitals = new HashMap<>();

我们在尖括号之间指定键的类型和值。 由于类型推断，因此不必在声明的右侧提供类型。

Java HashMap put()

put()方法用于向映射添加新的映射。

  1. capitals.put("svk", "Bratislava");

第一个参数是键，第二个是值。

Java HashMap remove()

remove()方法用于从映射中删除一对。

  1. capitals.remove("pol");

参数是要从映射中删除其映射的键。

Java HashMap初始化

从 Java 9 开始，我们有了用于HashMap初始化的工厂方法。

com/zetcode/HashMapInit.java

  1. package com.zetcode;
  3. import java.util.Map;
  5. import static java.util.Map.entry;
  7. // factory initialization methods since Java 9
  8. public class HashMapInit {
  10.     public static void main(String[] args) {
  12.         // up to 10 elements:
  13.         Map<Integer, String> colours = Map.of(
  14.                 1, "red",
  15.                 2, "blue",
  16.                 3, "brown"
  17.         );
  19.         System.out.println(colours);
  21.         // any number of elements
  22.         Map<String, String> countries = Map.ofEntries(
  23.                 entry("de", "Germany"),
  24.                 entry("sk", "Slovakia"),
  25.                 entry("ru", "Russia")
  26.         );
  28.         System.out.println(countries);
  29.     }
  30. }

该示例使用Map.of和Map.ofEntries初始化哈希图。 这两个工厂方法返回不可修改的映射。

com/zetcode/HashMapInit2.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. // up to Java8
  7. public class HashMapInit2 {
  9.     public static void main(String[] args) {
  11.         Map<String, String> countries = new HashMap<>() {{
  12.             put("de", "Germany");
  13.             put("sk", "Slovakia");
  14.             put("ru", "Russia");
  15.         }};
  17.         System.out.println(countries);
  18.     }
  19. }

在此示例中，我们创建了一个可修改的哈希图。 这种初始化方式称为双括号哈希图初始化。

Java HashMap大小示例

HashMap的大小由size()方法确定。

com/zetcode/HashMapSize.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class HashMapSize {
  8.     public static void main(String[] args) {
  10.         Map<String, String> capitals = new HashMap<>();
  12.         capitals.put("svk", "Bratislava");
  13.         capitals.put("ger", "Berlin");
  14.         capitals.put("hun", "Budapest");
  15.         capitals.put("czk", "Prague");
  16.         capitals.put("pol", "Warsaw");
  17.         capitals.put("ita", "Rome");
  19.         int size = capitals.size();
  21.         System.out.printf("The size of the HashMap is %d%n", size);
  23.         capitals.remove("pol");
  24.         capitals.remove("ita");
  26.         size = capitals.size();
  28.         System.out.printf("The size of the HashMap is %d%n", size);
  29.     }
  30. }

在代码示例中，我们创建HashMap并使用size()确定其大小。 然后，我们删除一些对，然后再次确定其大小。 我们将发现结果打印到控制台。

  1. capitals.put("svk", "Bratislava");
  2. capitals.put("ger", "Berlin");

使用put()，我们将新的对添加到HashMap中。

  1. int size = capitals.size();

在这里，我们得到映射的大小。

  1. capitals.remove("pol");
  2. capitals.remove("ita");

使用remove()，我们从映射中删除了两对。

  1. The size of the HashMap is 6
  2. The size of the HashMap is 4

这是示例的输出。

Java HashMap get()

要从HashMap检索值，我们使用get()方法。 它以键作为参数。

com/zetcode/HashMapRetrieve.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class HashMapRetrieve {
  8.     public static void main(String[] args) {
  10.         Map<String, String> capitals = new HashMap<>();
  12.         capitals.put("svk", "Bratislava");
  13.         capitals.put("ger", "Berlin");
  14.         capitals.put("hun", "Budapest");
  15.         capitals.put("czk", "Prague");
  16.         capitals.put("pol", "Warsaw");
  17.         capitals.put("ita", "Rome");
  19.         String cap1 = capitals.get("ita");
  20.         String cap2 = capitals.get("svk");
  22.         System.out.println(cap1);
  23.         System.out.println(cap2);
  24.     }
  25. }

在示例中，我们从映射中检索两个值。

  1. String cap2 = capitals.get("svk");

在这里，我们得到一个具有"svk"键的值。

Java HashMap clear()

clear()方法从HashMap中删除所有对。

com/zetcode/HashMapClear.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class HashMapClear {
  8.     public static void main(String[] args) {
  10.         Map<String, String> capitals = new HashMap<>();
  12.         capitals.put("svk", "Bratislava");
  13.         capitals.put("ger", "Berlin");
  14.         capitals.put("hun", "Budapest");
  15.         capitals.put("czk", "Prague");
  16.         capitals.put("pol", "Warsaw");
  17.         capitals.put("ita", "Rome");
  19.         capitals.clear();
  21.         if (capitals.isEmpty()) {
  23.             System.out.println("The map is empty");
  24.         } else {
  26.             System.out.println("The map is not empty");
  27.         }
  28.     }
  29. }

在该示例中，我们删除了所有元素，并将映射的大小打印到控制台。

  1. capitals.clear();

我们用clear()删除所有对。

  1. if (capitals.isEmpty()) {
  3.     System.out.println("The map is empty");
  4. } else {
  6.     System.out.println("The map is not empty");
  7. }

使用isEmpty()方法，我们检查映射是否为空。

Java HashMap containsKey()

如果映射包含指定键的映射，则containsKey()方法返回true。

com/zetcode/HashMapContainsKey.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class HashMapContainsKey {
  8.     public static void main(String[] args) {
  10.         Map<String, String> capitals = new HashMap<>();
  12.         capitals.put("svk", "Bratislava");
  13.         capitals.put("ger", "Berlin");
  14.         capitals.put("hun", "Budapest");
  15.         capitals.put("czk", "Prague");
  16.         capitals.put("pol", "Warsaw");
  17.         capitals.put("ita", "Rome");
  19.         String key1 = "ger";
  20.         String key2 = "rus";
  22.         if (capitals.containsKey(key1)) {
  24.             System.out.printf("HashMap contains %s key%n", key1);
  25.         } else {
  27.             System.out.printf("HashMap does not contain %s key%n", key1);
  28.         }
  30.         if (capitals.containsKey(key2)) {
  32.             System.out.printf("HashMap contains %s key%n", key2);
  33.         } else {
  35.             System.out.printf("HashMap does not contain %s key%n", key2);
  36.         }
  37.     }
  38. }

在示例中，我们检查映射是否包含两个键。

  1. if (capitals.containsKey(key1)) {
  3.     System.out.printf("HashMap contains %s key%n", key1);
  4. } else {
  6.     System.out.printf("HashMap does not contain %s key%n", key1);
  7. }

该if语句根据映射是否包含给定键输出消息。

  1. HashMap contains ger key
  2. HashMap does not contain rus key

这是输出。

Java HashMap replace()

有replace()方法使程序员可以替换条目。

  1. replace(K key, V value)

仅当当前映射到某个值时，此方法才替换指定键的条目。

  1. replace(K key, V oldValue, V newValue)

仅当当前映射到指定值时，此方法才替换指定键的条目。

com/zetcode/HashMapReplace.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class HashMapReplace {
  8.     public static void main(String[] args) {
  10.         Map<String, String> capitals = new HashMap<>();
  12.         capitals.put("day", "Monday");
  13.         capitals.put("country", "Poland");
  14.         capitals.put("colour", "blue");
  16.         capitals.replace("day", "Sunday");
  17.         capitals.replace("country", "Russia", "Great Britain");
  18.         capitals.replace("colour", "blue", "green");
  20.         capitals.entrySet().forEach(System.out::println);
  21.     }
  22. }

在示例中，我们将映射中的对替换为replace()。

  1. capitals.replace("day", "Sunday");

在这里，我们替换"day"键的值。

  1. capitals.replace("country", "Russia", "Great Britain");

在这种情况下，由于键当前未设置为"Russia"，因此不会替换该值。

  1. capitals.replace("colour", "blue", "green");

由于旧值正确，因此将替换该值。

  1. country=Poland
  2. colour=green
  3. day=Sunday

这是输出。

Java HashMap转换为List

在下一个示例中，我们将HashMap条目转换为条目列表。

com/zetcode/HashMapConvert.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.Set;
  8. public class HashMapConvert {
  10.     public static void main(String[] args) {
  12.         Map<String, String> colours = Map.of(
  13.                 "AliceBlue", "#f0f8ff",
  14.                 "GreenYellow", "#adff2f",
  15.                 "IndianRed", "#cd5c5c",
  16.                 "khaki", "#f0e68c"
  17.         );
  19.         Set<Map.Entry<String, String>> entries = colours.entrySet();
  20.         List<Map.Entry<String, String>> mylist = new ArrayList<>(entries);
  22.         System.out.println(mylist);
  23.     }
  24. }

entrySet()返回映射的设置视图，该视图随后传递给ArrayList的构造器。

使用forEach()迭代HashMap

我们使用 Java8 forEach()方法来迭代HashMap的键值对。 forEach()方法对映射的每个元素执行给定的操作，直到所有元素都已处理或该操作引发异常。

com/zetcode/HashMapForEach.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class HashMapForEach {
  8.     public static void main(String[] args) {
  10.         Map<String, String> capitals = new HashMap<>();
  12.         capitals.put("svk", "Bratislava");
  13.         capitals.put("ger", "Berlin");
  14.         capitals.put("hun", "Budapest");
  15.         capitals.put("czk", "Prague");
  16.         capitals.put("pol", "Warsaw");
  17.         capitals.put("ita", "Rome");
  19.         capitals.forEach((k, v) -> System.out.format("%s: %s%n", k, v));
  20.     }
  21. }

在代码示例中，我们使用 lambda 表达式迭代了HashMap和forEach()。

  1. capitals.forEach((k, v) -> System.out.format("%s: %s%n", k, v));

使用forEach()，我们遍历了映射的所有对。

使用增强的for循环迭代HashMap

Java 5 中引入的增强的for循环可用于对HashMap进行迭代。

com/zetcode/HashMapEnhancedFor.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class HashMapEnhancedFor {
  8.     public static void main(String[] args) {
  10.         Map<String, String> capitals = new HashMap<>();
  12.         capitals.put("svk", "Bratislava");
  13.         capitals.put("ger", "Berlin");
  14.         capitals.put("hun", "Budapest");
  15.         capitals.put("czk", "Prague");
  16.         capitals.put("pol", "Warsaw");
  17.         capitals.put("ita", "Rome");
  19.         for (Map.Entry<String, String> pair: capitals.entrySet()) {
  21.             System.out.format("%s: %s%n", pair.getKey(), pair.getValue());
  22.         }
  23.     }
  24. }

在该示例中，我们迭代具有增强的for循环的HashMap。

  1. for (Map.Entry<String, String> pair: capitals.entrySet()) {
  3.     System.out.format("%s: %s%n", pair.getKey(), pair.getValue());
  4. }

在每个for周期中，都将新的键值对分配给pair变量。

Java HashMap迭代键

我们可能只想遍历HashMap的键。

com/zetcode/HashMapKeys.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. public class HashMapKeys {
  9.     public static void main(String[] args) {
  11.         Map<String, String> capitals = new HashMap<>();
  13.         capitals.put("svk", "Bratislava");
  14.         capitals.put("ger", "Berlin");
  15.         capitals.put("hun", "Budapest");
  16.         capitals.put("czk", "Prague");
  17.         capitals.put("pol", "Warsaw");
  18.         capitals.put("ita", "Rome");
  20.         Set<String> keys = capitals.keySet();
  22.         keys.forEach(System.out::println);
  23.     }
  24. }

该示例迭代capitals映射的键。

  1. Set<String> keys = capitals.keySet();

用keySet()方法检索HashMap的键，该方法返回键Set。 键必须唯一； 因此，我们有一个Set。 Set是一个不包含重复元素的集合。

  1. keys.forEach(System.out::println);

我们用forEach()遍历键集。

Java HashMap迭代值

我们可能只想对HashMap的值进行迭代。

com/zetcode/HashMapValues.java

  1. package com.zetcode;
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Map;
  7. public class HashMapValues {
  9.     public static void main(String[] args) {
  11.         Map<String, String> capitals = new HashMap<>();
  13.         capitals.put("svk", "Bratislava");
  14.         capitals.put("ger", "Berlin");
  15.         capitals.put("hun", "Budapest");
  16.         capitals.put("czk", "Prague");
  17.         capitals.put("pol", "Warsaw");
  18.         capitals.put("ita", "Rome");
  20.         Collection<String> vals = capitals.values();
  22.         vals.forEach(System.out::println);
  23.     }
  24. }

该示例迭代HashMap的值。

  1. Collection<String> vals = capitals.values();

HashMap的值通过values()方法检索。

  1. vals.forEach(System.out::println);

我们使用forEach()遍历集合。

HashMap过滤

可以使用 Java 流 API 的filter()方法过滤HashMap。

com/zetcode/HashMapFilter.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.stream.Collectors;
  7. public class HashMapFilter {
  9.     public static void main(String[] args) {
  11.         Map<String, String> capitals = new HashMap<>();
  13.         capitals.put("svk", "Bratislava");
  14.         capitals.put("ger", "Berlin");
  15.         capitals.put("hun", "Budapest");
  16.         capitals.put("czk", "Prague");
  17.         capitals.put("pol", "Warsaw");
  18.         capitals.put("ita", "Rome");
  20.         Map<String, String> filteredCapitals = capitals.entrySet().stream()
  21.                 .filter(map ->  map.getValue().length() == 6)
  22.                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
  24.         filteredCapitals.entrySet().forEach(System.out::println);
  25.     }
  26. }

在示例中，我们将映射过滤为仅包含值大小等于 6 的对。

  1. czk=Prague
  2. ger=Berlin
  3. pol=Warsaw

这是输出。

其他语言的 Java HashMap等效项

Ruby 具有哈希，Perl 具有哈希，PHP 具有数组，Python 具有字典，C# 具有字典，JavaScript 具有映射。

ruby_hash.rb

  1. #!/usr/bin/ruby
  3. stones = { 1 => "garnet", 2 => "topaz",
  4.            3 => "opal", 4 => "amethyst"
  5.          }
  7. stones.each { |k, v| puts "Key: #{k}, Value: #{v}" }

这是 Ruby 中的哈希。

perl_hash.py

  1. #!/usr/bin/perl
  3. my %stones = ( 1 => "garnet", 2 => "topaz",
  4.            3 => "opal", 4 => "amethyst" );
  6. while ( my ($k, $v) = each %stones ) {
  7.     print "$k: $v\n";
  8. }

这是一个 Perl 哈希。

php_array.php

  1. <?php
  3. $stones = [
  4.     1 => "garnet",
  5.     2 => "topaz",
  6.     3 => "opal",
  7.     4 => "amethyst"
  8. ];
  10. foreach ($stones as $key => $value) {
  11.     echo "$key: $value\n";
  12. }
  14. ?>

这是一个 PHP 数组。

python_dictionary.py

  1. #!/usr/bin/python
  3. stones = { 1 : "garnet",
  4.            2 : "topaz",
  5.            3 : "opal",
  6.            4 : "amethyst" }
  8. for key, value in stones.items():
  10.     print("{}: {}".format(key, value))

这是 Python 字典。

csharp_dictionary.cs

  1. using System;
  2. using System.Collections.Generic;
  4. public class DictionaryExample {
  6.     static void Main() {
  8.         Dictionary<int, string> stones = new Dictionary<int, string> {
  10.             { 1, "garnet" },
  11.             { 2, "topaz" },
  12.             { 3, "opal" },
  13.             { 4, "amethyst" },
  14.         };
  16.         Console.WriteLine("Keys and values of the dictionary:");
  18.         foreach(KeyValuePair<int, string> kvp in stones) {
  20.             Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
  21.         }
  22.     }
  23. }

这是 C# 词典。

javascript_map.js

  1. var stones = new Map();
  3. stones.set(1, 'garnet');
  4. stones.set(2, 'topaz');
  5. stones.set(3, 'opal');
  6. stones.set(4, 'amethyst');
  8. stones.forEach(function(value, key) {
  9.   console.log(key + ': ' + value);
  10. });

这是一个 JavaScript 映射。

在本教程中，我们介绍了 Java HashMap集合。 您可能也对相关教程感兴趣： Java 中的HashMap迭代， Java ArrayList教程， Java HashSet教程， Java static关键字 和 Java 教程。

列出所有 Java 教程。

{% endraw %}