EnumMap Class in Java

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.

MONDAY: 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.

Work
Relax

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

Example: This example demonstrates how to create, perform basic operation such as size, retrieval and check for keys and values on an EnumMap.

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.

EnumMap 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().

EnumMap: {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.

EnumMap 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.

EnumMap 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

Methods Declared in AbstractMap Class

Methods Declared in Interface java.util.Map

EnumMap vs EnumSet