EnumMap is a specialized implementation of the Map interface for enumeration types. It extends AbstractMap and implements the Map interface in Java. It belongs to java.util package. A few important features of EnumMap are as follows:
- The EnumMap class is a member of the Java Collections Framework and is not synchronized.
- EnumMap is an ordered collection and they are maintained in the natural order of their keys (the natural order of keys means the order in which enum constants are declared inside the enum type).
- It’s a high-performance map implementation, much faster than HashMap.
- All keys of each EnumMap instance must be keys of a single enum type.
- EnumMap doesn’t allow a null key and throws NullPointerException when we attempt to insert the null key.
- Iterators returned by the collection views are weakly consistent: they will never throw ConcurrentModificationException and they may or may not show the effects of any modifications to the map that occur while the iteration is in progress.
- EnumMap is internally represented as arrays. This representation is extremely compact and efficient.
Example: This example demonstrates adding elements to an EnumMap and printing them.
Java // Java Program to demonstrate // the working of EnumMap import java.util.EnumMap; enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } public class Geeks { public static void main(String[] args) { // Create an EnumMap for Day enum EnumMap<Day, String> dayMap = new EnumMap<>(Day.class); // Add elements to the EnumMap dayMap.put(Day.MONDAY, "Start of the week"); dayMap.put(Day.FRIDAY, "End of the week"); dayMap.put(Day.SUNDAY, "Weekend"); // Print all elements in the EnumMap for (Day day : dayMap.keySet()) { System.out.println(day + ": " + dayMap.get(day)); } } } OutputMONDAY: Start of the week FRIDAY: End of the week SUNDAY: Weekend
EnumMap Hierarchy
Declaration of EnumMap
In Java, the declaration of EnumMap can be done as:
EnumMap<EnumType, ValueType> map = new EnumMap<>(EnumType.class);
Note: EnumType is the type of the enum that will be used as keys in the map and ValueType is the type of the values associated with the enum keys.
The EnumMap class in Java is a specialized map implementation that is designed specifically for use with enum keys. An EnumMap is a compact, efficient, and fast alternative to using a HashMap with enum keys.
Example: This example demonstrates how to use an EnumMap in Java to store and retrieve values associated with enum keys.
Java // EnumMap to store and retrive // values associated with enum constants import java.util.EnumMap; enum Days { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } public class Geeks { public static void main(String[] args) { EnumMap<Days, String> e = new EnumMap<>(Days.class); // Adding elements to the EnumMap e.put(Days.MONDAY, "Work"); e.put(Days.TUESDAY, "Work"); e.put(Days.WEDNESDAY, "Study"); e.put(Days.THURSDAY, "Study"); e.put(Days.FRIDAY, "Relax"); // Getting elements from the EnumMap System.out.println(e.get(Days.MONDAY)); System.out.println(e.get(Days.FRIDAY)); } } Explanation: In this example, we define an enum type Days that represents the days of the week. We then create an EnumMap and add elements to it using the put method. Finally, we retrieve elements from the EnumMap using the get method and print the results to the console.
Constructors
Constructor | Description |
|---|
EnumMap(Class keyType) | This constructor is used to create an empty EnumMap with the specified keyType. |
EnumMap(EnumMap m) | This constructor is used to create an enum map with the same keyType as the specified enum map, with initial mappings being the same as the EnumMap |
EnumMap(Map m) | This constructor is used to create an enum map with initialization from the specified map in the parameter. |
Example: This example demonstrates how to create, perform basic operation such as size, retrieval and check for keys and values on an EnumMap.
Java // Java Program to create, perform basic operation import java.util.EnumMap; public class Geeks { // Defining an enum called GFG public enum GFG { CODE, CONTRIBUTE, QUIZ, MCQ } public static void main(String[] args) { // Creating an EnumMap where the key is // of type GFG and the value is a String EnumMap<GFG, String> e = new EnumMap<>(GFG.class); // Adding key-value pairs to the map e.put(GFG.CODE, "Start Coding with GFG"); e.put(GFG.CONTRIBUTE, "Contribute for others"); e.put(GFG.QUIZ, "Practice Quizzes"); e.put(GFG.MCQ, "Test Speed with MCQs"); // Printing the size of the EnumMap System.out.println("Size of EnumMap: " + e.size()); // Printing the contents of the EnumMap // The map will print in the natural order of // enum keys (the order in which they are defined) System.out.println("EnumMap: " + e); // Retrieving a value from the EnumMap using a specific key System.out.println("Value for CODE: " + e.get(GFG.CODE)); // Checking if the EnumMap contains a specific key System.out.println("Does gfgMap contain CONTRIBUTE? " + e.containsKey(GFG.CONTRIBUTE)); // Checking if the EnumMap contains a specific value System.out.println("Does gfgMap contain the value 'Practice Quizzes'? " + e.containsValue("Practice Quizzes")); // Checking if the EnumMap contains a null value // (which is not present in this example) System.out.println("Does gfgMap contain a null value? " + e.containsValue(null)); } } Output:
Performing Various Operations on LinkedTransferQueue
1. Adding Elements: We can use put() and putAll() method to insert elements to a EnumMap.
Example: This example demonstrates how to add elements to an EnumMap using put() and putAll() methods.
Java // Java Program to add elements to an EnumMap import java.util.EnumMap; class Geeks { enum Color { RED, GREEN, BLUE, WHITE } public static void main(String[] args) { // Creating an EnumMap of the Color enum EnumMap<Color, Integer> e = new EnumMap<>(Color.class); // Insert elements in Map // using put() method e.put(Color.RED, 1); e.put(Color.GREEN, 2); // Printing mappings to the console System.out.println("EnumMap colors1: " + e); // Creating an EnumMap of the Color Enum EnumMap<Color, Integer> e1 = new EnumMap<>(Color.class); // Adding elements using the putAll() method e1.putAll(e); e1.put(Color.BLUE, 3); // Printing mappings to the console System.out.println("EnumMap colors2: " + e1); } } OutputEnumMap colors1: {RED=1, GREEN=2} EnumMap colors2: {RED=1, GREEN=2, BLUE=3}
2. Accessing Elements: We can use entrySet(), keySet(), values() and get() to access the elements of EnumMap.
Example: This example demonstrates how to access elements of an EnumMap using methods like entrySet(), keySet(), values() and get().
Java // Java Program to Access the Elements of EnumMap import java.util.EnumMap; class Geeks { // Enum enum Color { RED, GREEN, BLUE, WHITE } public static void main(String[] args) { // Creating an EnumMap of the Color enum EnumMap<Color, Integer> e = new EnumMap<>(Color.class); // Inserting elements using put() method e.put(Color.RED, 1); e.put(Color.GREEN, 2); e.put(Color.BLUE, 3); e.put(Color.WHITE, 4); System.out.println("EnumMap: " + e); // Using the entrySet() method System.out.println("Key-Value mappings: " + e.entrySet()); // Using the keySet() method System.out.println("Keys: " + e.keySet()); // Using the values() method System.out.println("Values: " + e.values()); // Using the get() method System.out.println("Value of RED : " + e.get(Color.RED)); } } OutputEnumMap: {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. Removing Elements: We can use the remove() method to remove elements from the EnumMap.
Example: This example demonstrates how to remove elements from an EnumMap using remove() and the conditional remove(key,value) method.
Java // Java program to Remove Elements of EnumMap import java.util.EnumMap; class Geeks { enum Color { // Custom elements RED, GREEN, BLUE, WHITE } public static void main(String[] args) { // Creating an EnumMap of the Color enum EnumMap<Color, Integer> e = new EnumMap<>(Color.class); // Inserting elements in the Map // using put() method e.put(Color.RED, 1); e.put(Color.GREEN, 2); e.put(Color.BLUE, 3); e.put(Color.WHITE, 4); // Printing e in the EnumMap System.out.println("EnumMap e : " + e); // Removing a mapping // using remove() Method int i = e.remove(Color.WHITE); // Displaying the removed value System.out.println("Removed Value: " + i); // Removing specific color and storing boolean // if removed or not boolean b = e.remove(Color.RED, 1); // Printing the boolean result whether removed or // not System.out.println("Is the entry {RED=1} removed? " + b); // Printing the updated Map to the console System.out.println("Updated EnumMap: " + e); } } OutputEnumMap e : {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. Replacing Elements: Map interface provides three variations of the replace() method to change the mappings of EnumMap.
Example: This example demonstrates how to replace elements in an EnumMap using replace(), conditional replace(key, oldValue, newValue), and replaceAll() method.
Java // Java Program to Replace Elements of EnumMap import java.util.EnumMap; class Geeks { enum Color { RED, GREEN, BLUE, WHITE } public static void main(String[] args) { // Creating an EnumMap of the Color enum EnumMap<Color, Integer> e = new EnumMap<>(Color.class); // Inserting elements to Map // using put() method e.put(Color.RED, 1); e.put(Color.GREEN, 2); e.put(Color.BLUE, 3); e.put(Color.WHITE, 4); // Printing all elements inside above Map System.out.println("EnumMap e " + e); // Replacing certain elements depicting e // using the replace() method e.replace(Color.RED, 11); e.replace(Color.GREEN, 2, 12); // Printing the updated elements (e) System.out.println("EnumMap using replace(): " + e); // Replacing all e using the replaceAll() // method e.replaceAll((key, oldValue) -> oldValue + 3); // Printing the elements of above Map System.out.println("EnumMap using replaceAll(): " + e); } } OutputEnumMap e {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
The implementation of an EnumMap is not synchronized. This means that if multiple threads access a tree set concurrently, and at least one of the threads modifies the set, it must be synchronized externally. This is typically accomplished by using the synchronizedMap() method of the Collections class. This is best done at the creation time, to prevent accidental unsynchronized access.
Map<EnumKey, V> m = Collections.synchronizedMap(new EnumMap<EnumKey, V>(…));
Advantages
- Efficient: The EnumMap class provides fast and efficient access to elements stored in the map, making it a good choice for use in performance-critical applications.
- Compact: The EnumMap class uses a compact representation for the map, which means that it requires less memory than a HashMap or a TreeMap.
- Type-safe: The EnumMap class only allows keys of a specified enum type, which means that it provides type-safe behavior and eliminates the need for casting.
- Sorted keys: The EnumMap class provides sorted keys, which means that the elements in the map are ordered by the order in which the enum constants are declared.
Disadvantages
- Limited to enum keys: The EnumMap class can only be used with keys of an enum type, which means that it’s not suitable for use with other types of keys.
- Immutable keys: The EnumMap class uses enum keys, which are immutable and cannot be modified once they are created.
Methods
Method | Action Performed |
|---|
| clear() | Removes all mappings from this map. |
| clone() | Returns a shallow copy of this enum map. |
| containsKey?(Object key) | Returns true if this map contains a mapping for the specified key. |
| containsValue?(Object value) | Returns true if this map maps one or more keys to the specified value. |
| entrySet() | Returns a Set view of the mappings contained in this map. |
| equals?(Object o) | Compares the specified object with this map for equality. |
| get?(Object key) | Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key. |
| hashCode() | Returns the hash code value for this map. |
| keySet() | Returns a Set view of the keys contained in this map. |
| put?(K key, V value) | Associates the specified value with the specified key in this map. |
| putAll?(Map<? extends K,?? extends V> m) | Copies all of the mappings from the specified map to this map. |
| remove?(Object key) | Removes the mapping for this key from this map if present. |
| size() | Returns the number of key-value mappings in this map. |
| values() | Returns a Collection view of the values contained in this map. |
Methods Declared in AbstractMap Class
Method | Description |
|---|
| isEmpty() | Returns true if this map contains no key-value mappings. |
| toString() | Returns a string representation of this map. |
Methods Declared in Interface java.util.Map
Method | Descriptionenter |
|---|
| compute?(K key, BiFunction<? super K,?? super V,?? extends V> remappingFunction) | Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping). |
| computeIfAbsent?(K key, Function<? super K,?? extends V> mappingFunction) | If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null. |
| computeIfPresent?(K key, BiFunction<? super K,?? super V,?? extends V> remappingFunction) | If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value. |
| forEach?(BiConsumer<? super K,?? super V> action) | Performs the given action for each entry in this map until all entries have been processed or the action throws an exception. |
| getOrDefault?(Object key, V defaultValue) | Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key. |
| merge?(K key, V value, BiFunction<? super V,?? super V,?? extends V> remappingFunction) | If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value. |
| putIfAbsent?(K key, V value) | If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value. |
| remove?(Object key, Object value) | Removes the entry for the specified key only if it is currently mapped to the specified value. |
| replace?(K key, V value) | Replaces the entry for the specified key only if it is currently mapped to some value. |
| replace?(K key, V oldValue, V newValue) | Replaces the entry for the specified key only if currently mapped to the specified value. |
| replaceAll?(BiFunction<? super K,?? super V,?? extends V> function) | Replaces each entry’s value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception. |
EnumMap vs EnumSet
Property | EnumMap | EnumSet |
|---|
| Internal Representation | EnumMap is internally represented as arrays. The representation is compact and efficient. | EnumSet is internally represented as BitVector or sequence of bits. |
| Permits Null Elements? | Null keys are not allowed but Null values are allowed. | Null elements are not permitted. |
| Is the Abstract Class? | No | Yes |
| Instantiation | Since EnumMap is not an abstract class, it can be instantiated using the new operator. | It is an abstract class, it does not have a constructor. Enum set is created using its predefined methods like allOf(), noneOf(), of(), etc. |
| Implementation | EnumMap is a specialized Map implementation for use with enum type keys. | EnumSet is a specialized Set implementation for use with enum types. |