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: 

• EnumMap class is a member of the Java Collections Framework & 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 on which enum constants are declared inside 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 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.

Syntax: Declaration

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

Parameters:

• Key object type
• Value object type

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

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.

Here’s an example of how you can use the EnumMap class in Java:

output:
work 

Relax

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.

Advantages of using EnumMap:

1. 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.
2. Compact: The EnumMap class uses a compact representation for the map, which means that it requires less memory than a HashMap or a TreeMap.
3. 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.
4. 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 of using EnumMap:

1. 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.
2. Immutable keys: The EnumMap class uses enum keys, which are immutable and cannot be modified once they are created.

EnumMap Hierarchy 

 Constructors of EnumMap 

1. EnumMap(Class keyType): The constructor is used to create an empty EnumMap with the specified keyType.
2. EnumMap(EnumMap m): The 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
3. EnumMap(Map m): The constructor is used to create an enum map with initialization from the specified map in the parameter.

Example  

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

Operation 1: Adding Elements

In order to add elements to the EnumMap, we can use put() or putAll() method as shown below.

EnumMap colors1: {RED=1, GREEN=2}
EnumMap colors2: {RED=1, GREEN=2, BLUE=3}

 Operation 2: Accessing the Elements

We can access the elements of EnumMap using entrySet(), keySet(), values(), get(). The example below explains these methods.

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

Operation 3: Removing elements

In order to remove the elements, EnumMap provides two variations of the remove() method.

Example

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}

Operation 4: Replacing elements

Map interface provides three variations of the replace() method to change the mappings of EnumMap.

Example

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

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

Methods of EnumMap

• K – Type of the key object
• V – Type of the value object

Methods Declared in AbstractMap Class

Methods Declared in Interface java.util.Map

EnumMap vs EnumSet

See your article appearing on GeeksforGeek’s main page and help other Geeks.  

Example :

Explanation

EnumMap is a specialized implementation of the Map interface in Java that is designed to be used with enums as keys. It is a high-performance implementation that is guaranteed to have constant time performance in many basic operations, such as get() and put().

The EnumMap class is a strongly typed Map implementation, which means that it can only be used with enums as keys. Each instance of EnumMap is associated with a specific enum class, and the key set of the map is a subset of the enum values. This ensures that the keys are always unique and well-defined.

One of the primary advantages of using EnumMap is its performance. Since it is designed specifically for use with enums, it can be optimized to take advantage of the unique properties of enums. For example, the EnumMap implementation uses a compact array-based data structure internally, which provides constant time performance for many basic operations.

Program 

Color map: {RED=FF0000, GREEN=00FF00, BLUE=0000FF}
Value for GREEN: 00FF00
All key-value pairs:
RED -> FF0000
GREEN -> 00FF00
BLUE -> 0000FF

Here are some benefits of using EnumMap in Java:

Type safety: EnumMap is a strongly-typed implementation of Map that ensures that only enum constants can be used as keys. This provides type safety and reduces the risk of runtime errors caused by using the wrong key type.

Performance: EnumMap is designed to provide high performance when used with enums as keys. It uses a compact array-based data structure internally, which provides constant time performance for many basic operations.

Memory efficiency: Since EnumMap is designed to be used with enums as keys, it can be optimized to use less memory than other Map implementations. This can be particularly important when dealing with large numbers of enum constants.

Clear and concise code: Using EnumMap can make code clearer and more concise, particularly when dealing with operations that are specific to enums, such as iterating over all enum constants.

Standardized behavior: Since EnumMap is part of the Java Collections Framework, it provides a standardized way of using enums as keys in a Map. This can make code more consistent and easier to understand.

Overall, EnumMap provides a simple, efficient, and type-safe way to use enums as keys in a Map implementation. Its performance benefits and memory efficiency make it a good choice for applications that need to work with enums in this way.

Reference book:

“Java Performance: The Definitive Guide” by Scott Oaks is a comprehensive guide to optimizing the performance of Java applications. It includes a section on the use of specialized map implementations, including the EnumMap class.