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

在本教程中，我们将借助示例学习 Java EnumMap类及其操作。

Java 集合框架的EnumMap类为枚举的元素提供了映射实现。

在EnumMap中，枚举元素用作键。 它实现了Map接口。

Java `EnumMap` - 图1

在学习EnumMap之前，请确保了解 Java 枚举。

创建一个EnumMap

为了创建一个枚举映射，我们必须首先导入java.util.EnumMap包。 导入包后，可以使用以下方法在 Java 中创建枚举映射。

  1. enum Size {
  2.     SMALL, MEDIUM, LARGE, EXTRALARGE
  3. }
  5. EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);

在上面的示例中，我们创建了一个名为sizes的枚举映射。

这里，

  • Size - 映射到值的枚举的键
  • Integer - 与相应键关联的枚举映射的值

EnumMap的方法

EnumMap类提供了允许我们在枚举映射上执行各种元素的方法。

将元素插入EnumMap

  • put() - 将指定的键/值映射（条目）插入到枚举映射中
  • putAll() - 将指定映射的所有条目插入此映射

例如，

  1. import java.util.EnumMap;
  3. class Main {
  5.     enum Size {
  6.         SMALL, MEDIUM, LARGE, EXTRALARGE
  7.     }
  8.     public static void main(String[] args) {
  10.         // Creating an EnumMap of the Size enum
  11.         EnumMap<Size, Integer> sizes1 = new EnumMap<>(Size.class);
  13.         // Using the put() Method
  14.         sizes1.put(Size.SMALL, 28);
  15.         sizes1.put(Size.MEDIUM, 32);
  16.         System.out.println("EnumMap1: " + sizes1);
  18.         EnumMap<Size, Integer> sizes2 = new EnumMap<>(Size.class);
  20.         // Using the putAll() Method
  21.         sizes2.putAll(sizes1);
  22.         sizes2.put(Size.LARGE, 36);
  23.         System.out.println("EnumMap2: " + sizes2);
  24.     }
  25. }

输出

  1. EnumMap1: {SMALL=28, MEDIUM=32}
  2. EnumMap2: {SMALL=28, MEDIUM=32, LARGE=36}

在上面的示例中，我们使用putAll()方法将枚举映射size1的所有元素插入到size2的枚举图中。

也可以使用putAll()将元素从其他映射（例如HashMap，TreeMap等）插入到枚举映射中。 但是，所有映射都应具有相同的枚举类型。

访问EnumMap元素

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

  • entrySet() - 返回一个枚举映射的所有键/值映射（条目）的集合
  • keySet() - 返回一个枚举映射的所有键的集合
  • values() - 返回一个枚举映射的所有值的集合

例如：

  1. import java.util.EnumMap;
  3. class Main {
  5.     enum Size {
  6.         SMALL, MEDIUM, LARGE, EXTRALARGE
  7.     }
  8.     public static void main(String[] args) {
  10.         // Creating an EnumMap of the Size enum
  11.         EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
  12.         sizes.put(Size.SMALL, 28);
  13.         sizes.put(Size.MEDIUM, 32);
  14.         sizes.put(Size.LARGE, 36);
  15.         sizes.put(Size.EXTRALARGE, 40);
  16.         System.out.println("EnumMap: " + sizes);
  18.         // Using the entrySet() Method
  19.         System.out.println("Key/Value mappings: " + sizes.entrySet());
  21.         // Using the keySet() Method
  22.         System.out.println("Keys: " + sizes.keySet());
  24.         // Using the values() Method
  25.         System.out.println("Values: " + sizes.values());
  26.     }
  27. }

输出：

  1. EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
  2. Key/Value mappings: [SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40]
  3. Keys: [SMALL, MEDIUM, LARGE, EXTRALARGE]
  4. Values: [28, 32, 36, 40]

2.使用get()方法

get()方法返回与指定键关联的值。 如果找不到指定的键，则返回null。

例如：

  1. import java.util.EnumMap;
  3. class Main {
  5.     enum Size {
  6.         SMALL, MEDIUM, LARGE, EXTRALARGE
  7.     }
  8.     public static void main(String[] args) {
  10.         // Creating an EnumMap of the Size enum
  11.         EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
  12.         sizes.put(Size.SMALL, 28);
  13.         sizes.put(Size.MEDIUM, 32);
  14.         sizes.put(Size.LARGE, 36);
  15.         sizes.put(Size.EXTRALARGE, 40);
  16.         System.out.println("EnumMap: " + sizes);
  18.         // Using the get() Method
  19.         int value = sizes.get(Size.MEDIUM);
  20.         System.out.println("Value of MEDIUM: " + value);
  21.     }
  22. }

输出：

  1. EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
  2. Value of MEDIUM: 32

删除EnumMap元素

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

例如：

  1. import java.util.EnumMap;
  3. class Main {
  5.     enum Size {
  6.         SMALL, MEDIUM, LARGE, EXTRALARGE
  7.     }
  8.     public static void main(String[] args) {
  10.         // Creating an EnumMap of the Size enum
  11.         EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
  12.         sizes.put(Size.SMALL, 28);
  13.         sizes.put(Size.MEDIUM, 32);
  14.         sizes.put(Size.LARGE, 36);
  15.         sizes.put(Size.EXTRALARGE, 40);
  16.         System.out.println("EnumMap: " + sizes);
  18.         // Using the remove() Method
  19.         int value = sizes.remove(Size.MEDIUM);
  20.         System.out.println("Removed Value: " + value);
  22.         boolean result = sizes.remove(Size.SMALL, 28);
  23.         System.out.println("Is the entry {SMALL=28} removed? " + result);
  25.         System.out.println("Updated EnumMap: " + sizes);
  26.     }
  27. }

输出：

  1. EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
  2. Removed Value: 32
  3. Is the entry {SMALL=28} removed? True
  4. Updated EnumMap: {LARGE=36, EXTRALARGE=40}

替换EnumMap元素

  • replace(key, value) - 用新的value替换与指定的key相关的值
  • replace(key, old, new) - 仅当old值已与指定的key关联时，才用new值替换old值。
  • replaceAll(function) - 用指定的function的结果替换映射的每个值
  1. import java.util.EnumMap;
  3. class Main {
  5.     enum Size {
  6.         SMALL, MEDIUM, LARGE, EXTRALARGE
  7.     }
  8.     public static void main(String[] args) {
  10.         // Creating an EnumMap of the Size enum
  11.         EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
  12.         sizes.put(Size.SMALL, 28);
  13.         sizes.put(Size.MEDIUM, 32);
  14.         sizes.put(Size.LARGE, 36);
  15.         sizes.put(Size.EXTRALARGE, 40);
  16.         System.out.println("EnumMap: " + sizes);
  18.         // Using the replace() Method
  19.         sizes.replace(Size.MEDIUM, 30);
  20.         sizes.replace(Size.LARGE, 36, 34);
  21.         System.out.println("EnumMap using replace(): " + sizes);
  23.         // Using the replaceAll() Method
  24.         sizes.replaceAll((key, oldValue) -> oldValue + 3);
  25.         System.out.println("EnumMap using replaceAll(): " + sizes);
  26.     }
  27. }

输出：

  1. EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
  2. EnumMap using replace(): {SMALL=28, MEDIUM=30, LARGE=34, EXTRALARGE=40}
  3. EnumMap using replaceAll(): {SMALL=31, MEDIUM=33, LARGE=37, EXTRALARGE=43}

在上面的程序中，请注意以下语句

  1. sizes.replaceAll((key, oldValue) -> oldValue + 3);

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

其他方法

方法 描述
clone() 创建EnumMap的副本
containsKey() 在EnumMap中搜索指定的键，并返回布尔结果
containsValue() 在EnumMap中搜索指定的值并返回布尔结果
size() 返回EnumMap的大小
clear() 从EnumMap中删除所有条目

EnumSet与EnumMap

EnumSet 和EnumMap类都提供用于存储枚举值的数据结构。 但是，它们之间存在一些主要差异。

  • 枚举集在内部以位序列表示，而枚举图在内部以数组表示。
  • 枚举集是使用其预定义方法（例如allOf()，noneOf()，of()等）创建的。但是，枚举映射是使用其构造器创建的。

Cloneable和Serializable接口

EnumMap类还实现Cloneable和Serializable接口。

Cloneable接口

它允许EnumMap类制作该类实例的副本。

Serializable接口

每当需要通过网络传输 Java 对象时，就需要将对象转换为位或字节。 这是因为 Java 对象无法通过网络传输。

Serializable接口允许对类进行序列化。 这意味着可以将实现Serializable的类的对象转换为位或字节。