当前位置: 首页>>代码示例 >>用法及示例精选 >>正文


Java EnumMap用法及代码示例


EnumMap 是 Map interfaceenumeration types 的专门实现。它扩展了 AbstractMap 并实现了 Java 中的 Map 接口。它属于java.util package。 EnumMap的一些重要特征如下:

  • EnumMap 类是 Java Collections Framework 的成员且未同步。
  • EnumMap 是一个有序集合,它们按照键的自然顺序维护(键的自然顺序是指枚举类型中声明枚举常量的顺序)
  • 这是一个高性能的Map实现,比 HashMap 快得多。
  • 每个EnumMap实例的所有键必须是单个enum类型的键。
  • EnumMap 不允许空键并抛出异常NullPointerException 当我们尝试插入空键时。
  • 集合视图返回的迭代器是弱一致的:它们永远不会抛出ConcurrentModificationException,并且它们可能会也可能不会显示迭代过程中发生的任何映射修改的效果。
  • EnumMap 在内部表示为数组。这种表示方式极其紧凑且高效。

用法:声明

public class EnumMap<K extends Enum<K>,?V> extends AbstractMap<K,?V> implements Serializable, Cloneable

参数:

  • 关键对象类型
  • 值对象类型

K must extend Enum, which enforces the requirement that the keys must be of the specified enum type. 

Java 中的 EnumMap 类是专门为与枚举键一起使用而设计的专用映射实现。 EnumMap 是使用带有枚举键的 HashMap 的紧凑、高效且快速的替代方案。

以下是如何在 Java 中使用 EnumMap 类的示例:

Java


import java.util.EnumMap; 
  
enum Days { 
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY 
} 
  
public class EnumMapExample { 
    public static void main(String[] args) { 
        EnumMap<Days, String> schedule = new EnumMap<>(Days.class); 
          
        // Adding elements to the EnumMap 
        schedule.put(Days.MONDAY, "Work"); 
        schedule.put(Days.TUESDAY, "Work"); 
        schedule.put(Days.WEDNESDAY, "Study"); 
        schedule.put(Days.THURSDAY, "Study"); 
        schedule.put(Days.FRIDAY, "Relax"); 
          
        // Getting elements from the EnumMap 
        System.out.println(schedule.get(Days.MONDAY)); // Output: Work 
        System.out.println(schedule.get(Days.FRIDAY)); // Output: Relax 
    } 
} 

output:
工作

放松

在此示例中,我们定义了一个枚举类型 Days 来表示一周中的几天。然后我们创建一个 EnumMap 并使用 put 方法向其中添加元素。最后,我们使用 get 方法从 EnumMap 检索元素并将结果打印到控制台。

使用 EnumMap 的优点:

  1. 高效:EnumMap 类提供对存储在映射中的元素的快速高效的访问,使其成为在 performance-critical 应用程序中使用的不错选择。
  2. 紧凑:EnumMap 类使用紧凑的映射表示形式,这意味着它比 HashMap 或 TreeMap 需要更少的内存。
  3. 类型安全:EnumMap 类仅允许指定枚举类型的键,这意味着它提供类型安全行为并消除了强制转换的需要。
  4. 排序键:EnumMap 类提供排序键,这意味着映射中的元素按声明枚举常量的顺序排序。

使用 EnumMap 的缺点:

  1. 仅限于枚举键:EnumMap 类只能与枚举类型的键一起使用,这意味着它不适合与其他类型的键一起使用。
  2. 不可变键:EnumMap 类使用枚举键,它们是不可变的,一旦创建就无法修改。

EnumMap 层次结构

EnumMap-in-Java

EnumMap 的构造函数

  1. EnumMap(类键类型):构造函数用于创建一个空的 EnumMap 并指定 key 类型.
  2. 枚举映射(枚举映射米):构造函数用于创建与指定枚举映射具有相同 keyType 的枚举映射,初始映射与 EnumMap 相同
  3. EnumMap(Map m):构造函数用于创建一个枚举映射,并从参数中指定的映射进行初始化。

示例

Java


// Java Program to illustrate Working of EnumMap class 
// and its functions 
  
// Importing EnumMap class 
import java.util.EnumMap; 
  
// Main class 
public class EnumMapExample { 
  
    // Enum 
    public enum GFG { 
        CODE, 
        CONTRIBUTE, 
        QUIZ, 
        MCQ; 
    } 
  
    // Main driver method 
    public static void main(String args[]) 
    { 
  
        // Java EnumMap 
        // Creating an empty EnumMap with key 
        // as enum type state 
        EnumMap<GFG, String> gfgMap 
            = new EnumMap<GFG, String>(GFG.class); 
  
        // Putting values inside EnumMap in Java 
        // Inserting Enum keys different from 
        // their natural order 
        gfgMap.put(GFG.CODE, "Start Coding with gfg"); 
        gfgMap.put(GFG.CONTRIBUTE, "Contribute for others"); 
        gfgMap.put(GFG.QUIZ, "Practice Quizes"); 
        gfgMap.put(GFG.MCQ, "Test Speed with Mcqs"); 
  
        // Printing size of EnumMap 
        System.out.println("Size of EnumMap in java: "
                           + gfgMap.size()); 
  
        // Printing Java EnumMap 
        // Print EnumMap in natural order 
        // of enum keys (order on which they are declared) 
        System.out.println("EnumMap: " + gfgMap); 
  
        // Retrieving value from EnumMap 
        System.out.println("Key : " + GFG.CODE + " Value: "
                           + gfgMap.get(GFG.CODE)); 
  
        // Checking if EnumMap contains a particular key 
        System.out.println( 
            "Does gfgMap has " + GFG.CONTRIBUTE + ": "
            + gfgMap.containsKey(GFG.CONTRIBUTE)); 
  
        // Checking if EnumMap contains a particular value 
        System.out.println( 
            "Does gfgMap has :" + GFG.QUIZ + " : "
            + gfgMap.containsValue("Practice Quizes")); 
        System.out.println("Does gfgMap has :" + GFG.QUIZ 
                           + " : "
                           + gfgMap.containsValue(null)); 
    } 
}
输出
Size of EnumMap in java: 4
EnumMap: {CODE=Start Coding with gfg, CONTRIBUTE=Contribute for others, QUIZ=Practice Quizes, MCQ=Test Speed with Mcqs}
Key : CODE Value: Start Coding with gfg
Does gfgMap has CONTRIBUTE: true
Does gfgMap has :QUIZ : true
Does gfgMap has :QUIZ : false

Basic Operations on EnumMap

操作一:添加元素

为了向 EnumMap 添加元素,我们可以使用 put() 或 putAll() 方法,如下所示。

Java


// Java Program to Add Elements to the EnumMap 
  
// Importing EnumMap class 
import java.util.EnumMap; 
  
// Main class 
// AddingElementsToEnumMap 
class GFG { 
  
    enum Color { RED, GREEN, BLUE, WHITE } 
    public static void main(String[] args) 
    { 
  
        // Creating an EnumMap of the Color enum 
        EnumMap<Color, Integer> colors1 
            = new EnumMap<>(Color.class); 
  
        // Insert elements in Map 
        // using put() method 
        colors1.put(Color.RED, 1); 
        colors1.put(Color.GREEN, 2); 
  
        // Printing mappings to the console 
        System.out.println("EnumMap colors1: " + colors1); 
  
        // Creating an EnumMap of the Color Enum 
        EnumMap<Color, Integer> colors2 
            = new EnumMap<>(Color.class); 
  
        // Adding elements using the putAll() method 
        colors2.putAll(colors1); 
        colors2.put(Color.BLUE, 3); 
  
        // Printing mappings to the console 
        System.out.println("EnumMap colors2: " + colors2); 
    } 
}
输出
EnumMap colors1: {RED=1, GREEN=2}
EnumMap colors2: {RED=1, GREEN=2, BLUE=3}

操作 2:访问元素

我们可以使用entrySet()、keySet()、values()、get()访问EnumMap的元素。下面的示例解释了这些方法。

Java


// Java Program to Access the Elements of EnumMap 
  
// Importing required classes 
import java.util.EnumMap; 
  
// Main class 
// AccessElementsOfEnumMap 
class GFG { 
  
    // Enum 
    enum Color { RED, GREEN, BLUE, WHITE } 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
  
        // Creating an EnumMap of the Color enum 
        EnumMap<Color, Integer> colors 
            = new EnumMap<>(Color.class); 
  
        // Inserting elements using put() method 
        colors.put(Color.RED, 1); 
        colors.put(Color.GREEN, 2); 
        colors.put(Color.BLUE, 3); 
        colors.put(Color.WHITE, 4); 
  
        System.out.println("EnumMap colors : " + colors); 
  
        // Using the entrySet() method 
        System.out.println("Key/Value mappings: "
                           + colors.entrySet()); 
  
        // Using the keySet() method 
        System.out.println("Keys: " + colors.keySet()); 
  
        // Using the values() method 
        System.out.println("Values: " + colors.values()); 
  
        // Using the get() method 
        System.out.println("Value of RED : "
                           + colors.get(Color.RED)); 
    } 
}
输出
EnumMap colors : {RED=1, GREEN=2, BLUE=3, WHITE=4}
Key/Value mappings: [RED=1, GREEN=2, BLUE=3, WHITE=4]
Keys: [RED, GREEN, BLUE, WHITE]
Values: [1, 2, 3, 4]
Value of RED : 1

操作3:删除元素

为了删除元素,EnumMap 提供了 remove() 方法的两种变体。

示例

Java


// Java program to Remove Elements of EnumMap 
  
// Importing EnumMap class 
import java.util.EnumMap; 
  
// Main class 
class GFG { 
  
    // Enum 
    enum Color { 
  
        // Custom elements 
        RED, 
        GREEN, 
        BLUE, 
        WHITE 
    } 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
  
        // Creating an EnumMap of the Color enum 
        EnumMap<Color, Integer> colors 
            = new EnumMap<>(Color.class); 
  
        // Inserting elements in the Map 
        // using put() method 
        colors.put(Color.RED, 1); 
        colors.put(Color.GREEN, 2); 
        colors.put(Color.BLUE, 3); 
        colors.put(Color.WHITE, 4); 
  
        // Printing colors in the EnumMap 
        System.out.println("EnumMap colors : " + colors); 
  
        // Removing a mapping 
        // using remove() Method 
        int value = colors.remove(Color.WHITE); 
  
        // Displaying the removed value 
        System.out.println("Removed Value: " + value); 
  
        // Removing specific color and storing boolean 
        // if removed or not 
        boolean result = colors.remove(Color.RED, 1); 
  
        // Printing the boolean result whether removed or 
        // not 
        System.out.println("Is the entry {RED=1} removed? "
                           + result); 
  
        // Printing the updated Map to the console 
        System.out.println("Updated EnumMap: " + colors); 
    } 
}
输出
EnumMap colors : {RED=1, GREEN=2, BLUE=3, WHITE=4}
Removed Value: 4
Is the entry {RED=1} removed? true
Updated EnumMap: {GREEN=2, BLUE=3}

操作4:替换元素

Map interface 提供了 replace() 方法的三种变体来更改 EnumMap 的映射。

示例

Java


// Java Program to Replace Elements of EnumMap 
  
// Importing required classes 
import java.util.EnumMap; 
  
// Main class 
class GFG { 
  
    // Enum 
    enum Color { 
  
        RED, 
        GREEN, 
        BLUE, 
        WHITE 
    } 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
  
        // Creating an EnumMap of the Color enum 
        EnumMap<Color, Integer> colors 
            = new EnumMap<>(Color.class); 
  
        // Inserting elements to Map 
        // using put() method 
        colors.put(Color.RED, 1); 
        colors.put(Color.GREEN, 2); 
        colors.put(Color.BLUE, 3); 
        colors.put(Color.WHITE, 4); 
  
        // Printing all elements inside above Map 
        System.out.println("EnumMap colors " + colors); 
  
        // Replacing certain elements depicting colors 
        // using the replace() method 
        colors.replace(Color.RED, 11); 
        colors.replace(Color.GREEN, 2, 12); 
  
        // Printing the updated elements (colors) 
        System.out.println("EnumMap using replace(): "
                           + colors); 
  
        // Replacing all colors using the replaceAll() 
        // method 
        colors.replaceAll((key, oldValue) -> oldValue + 3); 
  
        // Printing the elements of above Map 
        System.out.println("EnumMap using replaceAll(): "
                           + colors); 
    } 
}
输出
EnumMap colors {RED=1, GREEN=2, BLUE=3, WHITE=4}
EnumMap using replace(): {RED=11, GREEN=12, BLUE=3, WHITE=4}
EnumMap using replaceAll(): {RED=14, GREEN=15, BLUE=6, WHITE=7}

Synchronized EnumMap

EnumMap 的实现不同步。这意味着如果多个线程同时访问一个树集,并且至少有一个线程修改了该集,则必须进行外部同步。这通常是通过使用 Collections class 的 synchronizedMap() 方法来完成的。最好在创建时完成此操作,以防止意外的不同步访问。

 Map<EnumKey, V> m = Collections.synchronizedMap(new EnumMap<EnumKey, V>(...));

Methods of EnumMap

  • K - 关键对象的类型
  • V - 值对象的类型

Method

执行的操作

EnumMap clear() 从此Map中删除所有映射。
EnumMap clone() 返回此枚举映射的浅拷贝。
EnumMap containsKey() 如果此映射包含指定键的映射,则返回 true。
EnumMap containsValue(value) 如果此映射将一个或多个键映射到指定值,则返回 true。
EnumMap entrySet() 返回此映射中包含的映射的集合视图。
EnumMap equals() 比较指定对象与此映射是否相等。
EnumMap get() 返回指定键映射到的值,如果此映射不包含该键的映射,则返回 null。
hashCode() 返回此映射的哈希代码值。
EnumMap keySet() 返回此映射中包含的键的集合视图。
EnumMap put() 将指定值与此映射中的指定键相关联。
EnumMap putAll(map) 将指定映射中的所有映射复制到此映射。
EnumMap remove() 从此映射中删除此键的映射(如果存在)。
EnumMap size() 返回此映射中键值映射的数量。
EnumMap values() 返回此映射中包含的值的集合视图。

Methods Declared in AbstractMap Class

Method

Description

AbstractMap isEmpty() 如果此映射不包含键值映射,则返回 true。
toString() 返回此Map的字符串表示形式。

Methods Declared in Interface java.util.Map

Method

说明输入

计算?(K key, BiFunction<? super K,?? super V,?? extends V> remappingFunction) 尝试计算指定键及其当前映射值的映射(如果没有当前映射,则为 null)。
computeIfAbsent?(K key, Function<? super K,?? 扩展 V> 映射函数) 如果指定的键尚未与值关联(或映射为 null),则尝试使用给定的映射函数计算其值并将其输入到此映射中,除非 null。
computeIfPresent?(K key, BiFunction<? super K,?? super V,?? extends V> remappingFunction) 如果指定键的值存在且非空,则尝试在给定键及其当前映射值的情况下计算新映射。
forEach?(BiConsumer<?超级K,??超级V>动作) 对此映射中的每个条目执行给定的操作,直到处理完所有条目或该操作引发异常。
getOrDefault?(对象键,V defaultValue) 返回指定键映射到的值,如果此映射不包含该键的映射,则返回 defaultValue。
合并?(K key, V value, BiFunction<? super V,?? super V,?? extends V> remappingFunction) 如果指定的键尚未与值关联或与 null 关联,则将其与给定的非 null 值关联。
putIfAbsent?(K 键,V 值) 如果指定的键尚未与值关联(或映射为 null),则将其与给定值关联并返回 null,否则返回当前值。
删除?(对象键,对象值) 仅当指定键当前映射到指定值时,才删除该条目。
替换?(K键,V值) 仅当指定键当前映射到某个值时才替换该条目。
替换?(K 键,V 旧值,V 新值) 仅当当前映射到指定值时才替换指定键的条目。
ReplaceAll?(BiFunction<? super K,?? super V,?? extends V> 函数) 将每个条目的值替换为在该条目上调用给定函数的结果,直到处理完所有条目或函数引发异常。

EnumMap vs EnumSet

Property

EnumMap

EnumSet

内部代表 EnumMap 在内部表示为数组。表示形式紧凑且高效。 EnumSet 在内部表示为BitVector 或位序列。
允许空元素吗? 不允许使用 Null 键,但允许使用 Null 值。 不允许使用空元素。
抽象类? No Yes
Instantiation 由于EnumMap不是抽象类,因此可以使用new运算符对其进行实例化。 它是一个抽象类,没有构造函数。枚举集是使用其预定义方法创建的,例如 allOf()、noneOf()、of() 等。
Implementation EnumMap 是与枚举类型键一起使用的专用 Map 实现。 EnumSet 是一个专门用于枚举类型的 Set 实现。

查看您的文章出现在 GeeksforGeek 的主页上并帮助其他极客。

例子:

解释

EnumMap 是 Java 中 Map 接口的专门实现,旨在与枚举作为键一起使用。它是一种高性能实现,保证在许多基本操作中具有恒定的时间性能,例如get()和put()。

EnumMap 类是强类型 Map 实现,这意味着它只能与枚举一起用作键。 EnumMap 的每个实例都与特定的枚举类相关联,并且映射的键集是枚举值的子集。这确保了键始终是唯一且定义良好的。

使用 EnumMap 的主要优点之一是其性能。由于它是专门为与枚举一起使用而设计的,因此可以对其进行优化以利用枚举的独特属性。例如,EnumMap 实现内部使用紧凑的基于数组的数据结构,为许多基本操作提供恒定时间性能。

程序

Java


import java.util.EnumMap; 
import java.util.Map; 
  
public class EnumMapExample { 
      
    enum Color { 
        RED, GREEN, BLUE 
    } 
      
    public static void main(String[] args) { 
        // create an EnumMap with Color enum as keys and String as values 
        EnumMap<Color, String> colorMap = new EnumMap<>(Color.class); 
          
        // add some key-value pairs to the map 
        colorMap.put(Color.RED, "FF0000"); 
        colorMap.put(Color.GREEN, "00FF00"); 
        colorMap.put(Color.BLUE, "0000FF"); 
          
        // print the map 
        System.out.println("Color map: " + colorMap); 
          
        // get the value associated with a particular key 
        String greenValue = colorMap.get(Color.GREEN); 
        System.out.println("Value for GREEN: " + greenValue); 
          
        // iterate over the map and print all key-value pairs 
        System.out.println("All key-value pairs:"); 
        for (Map.Entry<Color, String> entry : colorMap.entrySet()) { 
            System.out.println(entry.getKey() + " -> " + entry.getValue()); 
        } 
    } 
} 
输出
Color map: {RED=FF0000, GREEN=00FF00, BLUE=0000FF}
Value for GREEN: 00FF00
All key-value pairs:
RED -> FF0000
GREEN -> 00FF00
BLUE -> 0000FF

以下是在 Java 中使用 EnumMap 的一些好处:

类型安全:EnumMap 是 Map 的强类型实现,确保只有枚举常量可以用作键。这提供了类型安全性并降低了由于使用错误的 key 类型而导致运行时错误的风险。

性能:EnumMap 旨在与枚举作为键一起使用时提供高性能。它内部使用紧凑的基于数组的数据结构,为许多基本操作提供恒定时间性能。

内存效率:由于 EnumMap 被设计为与枚举一起用作键,因此可以对其进行优化,以比其他 Map 实现使用更少的内存。在处理大量枚举常量时,这一点尤其重要。

清晰简洁的代码:使用EnumMap可以使代码更加清晰简洁,特别是在处理特定于枚举的操作时,例如迭代所有枚举常量。

标准化行为:由于 EnumMap 是 Java Collections Framework 的一部分,因此它提供了一种使用枚举作为 Map 中的键的标准化方法。这可以使代码更加一致并且更容易理解。

总体而言,EnumMap 提供了一种简单、高效且类型安全的方法来在 Map 实现中使用枚举作为键。它的性能优势和内存效率使其成为需要以这种方式使用枚举的应用程序的不错选择。

参考书:

Scott Oaks 所著的《Java 性能:权威指南》是一本优化 Java 应用程序性能的综合指南。它包括有关使用专用Map实现的部分,包括EnumMap 类。



相关用法


注:本文由纯净天空筛选整理自佚名大神的英文原创作品 EnumMap class in Java。非经特殊声明,原始代码版权归原作者所有,本译文未经允许或授权,请勿转载或复制。