當前位置: 首頁>>代碼示例 >>用法及示例精選 >>正文


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。非經特殊聲明,原始代碼版權歸原作者所有,本譯文未經允許或授權,請勿轉載或複製。