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. |
Similar Reads
Java Tutorial Java is a high-level, object-oriented programming language used to build web apps, mobile applications, and enterprise software systems. Known for its Write Once, Run Anywhere capability, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).Syntax and s
10 min read
Basics
Introduction to JavaJava is a high-level, object-oriented programming language developed by Sun Microsystems in 1995. It is platform-independent, which means we can write code once and run it anywhere using the Java Virtual Machine (JVM). Java is mostly used for building desktop applications, web applications, Android
4 min read
Java Programming BasicsJava is one of the most popular and widely used programming language and platform. A platform is an environment that helps to develop and run programs written in any programming language. Java is fast, reliable and secure. From desktop to web applications, scientific supercomputers to gaming console
4 min read
Java MethodsJava Methods are blocks of code that perform a specific task. A method allows us to reuse code, improving both efficiency and organization. All methods in Java must belong to a class. Methods are similar to functions and expose the behavior of objects.Example: Java program to demonstrate how to crea
7 min read
Access Modifiers in JavaIn Java, access modifiers are essential tools that define how the members of a class, like variables, methods, and even the class itself, can be accessed from other parts of our program. They are an important part of building secure and modular code when designing large applications. In this article
6 min read
Arrays in JavaIn Java, an array is an important linear data structure that allows us to store multiple values of the same type. Arrays in Java are objects, like all other objects in Java, arrays implicitly inherit from the java.lang.Object class. This allows you to invoke methods defined in Object (such as toStri
9 min read
Java StringsIn Java, a String is the type of object that can store a sequence of characters enclosed by double quotes and every character is stored in 16 bits, i.e., using UTF 16-bit encoding. A string acts the same as an array of characters. Java provides a robust and flexible API for handling strings, allowin
8 min read
Regular Expressions in JavaIn Java, Regular Expressions or Regex (in short) in Java is an API for defining String patterns that can be used for searching, manipulating, and editing a string in Java. Email validation and passwords are a few areas of strings where Regex is widely used to define the constraints. Regular Expressi
7 min read
OOPs & Interfaces
Classes and Objects in JavaIn Java, classes and objects are basic concepts of Object Oriented Programming (OOPs) that are used to represent real-world concepts and entities. A class is a template to create objects having similar properties and behavior, or in other words, we can say that a class is a blueprint for objects.An
10 min read
Java ConstructorsIn Java, constructors play an important role in object creation. A constructor is a special block of code that is called when an object is created. Its main job is to initialize the object, to set up its internal state, or to assign default values to its attributes. This process happens automaticall
10 min read
Java OOP(Object Oriented Programming) ConceptsBefore Object-Oriented Programming (OOPs), most programs used a procedural approach, where the focus was on writing step-by-step functions. This made it harder to manage and reuse code in large applications.To overcome these limitations, Object-Oriented Programming was introduced. Java is built arou
10 min read
Java PackagesPackages in Java are a mechanism that encapsulates a group of classes, sub-packages and interfaces. Packages are used for: Prevent naming conflicts by allowing classes with the same name to exist in different packages, like college.staff.cse.Employee and college.staff.ee.Employee.They make it easier
8 min read
Java InterfaceAn Interface in Java programming language is defined as an abstract type used to specify the behaviour of a class. An interface in Java is a blueprint of a behaviour. A Java interface contains static constants and abstract methods. Key Properties of Interface:The interface in Java is a mechanism to
11 min read
Collections
Exception Handling
Java Exception HandlingException handling in Java is an effective mechanism for managing runtime errors to ensure the application's regular flow is maintained. Some Common examples of exceptions include ClassNotFoundException, IOException, SQLException, RemoteException, etc. By handling these exceptions, Java enables deve
8 min read
Java Try Catch BlockA try-catch block in Java is a mechanism to handle exceptions. This make sure that the application continues to run even if an error occurs. The code inside the try block is executed, and if any exception occurs, it is then caught by the catch block.Example: Here, we are going to handle the Arithmet
4 min read
Java final, finally and finalizeIn Java, the keywords "final", "finally" and "finalize" have distinct roles. final enforces immutability and prevents changes to variables, methods, or classes. finally ensures a block of code runs after a try-catch, regardless of exceptions. finalize is a method used for cleanup before an object is
4 min read
Chained Exceptions in JavaChained Exceptions in Java allow associating one exception with another, i.e. one exception describes the cause of another exception. For example, consider a situation in which a method throws an ArithmeticException because of an attempt to divide by zero.But the root cause of the error was an I/O f
3 min read
Null Pointer Exception in JavaA NullPointerException in Java is a RuntimeException. It occurs when a program attempts to use an object reference that has the null value. In Java, "null" is a special value that can be assigned to object references to indicate the absence of a value.Reasons for Null Pointer ExceptionA NullPointerE
5 min read
Exception Handling with Method Overriding in JavaException handling with method overriding in Java refers to the rules and behavior that apply when a subclass overrides a method from its superclass and both methods involve exceptions. It ensures that the overridden method in the subclass does not declare broader or new checked exceptions than thos
4 min read
Java Advanced
Java Multithreading TutorialThreads are the backbone of multithreading. We are living in the real world which in itself is caught on the web surrounded by lots of applications. With the advancement in technologies, we cannot achieve the speed required to run them simultaneously unless we introduce the concept of multi-tasking
15+ min read
Synchronization in JavaIn multithreading, synchronization is important to make sure multiple threads safely work on shared resources. Without synchronization, data can become inconsistent or corrupted if multiple threads access and modify shared variables at the same time. In Java, it is a mechanism that ensures that only
10 min read
File Handling in JavaIn Java, with the help of File Class, we can work with files. This File Class is inside the java.io package. The File class can be used to create an object of the class and then specifying the name of the file.Why File Handling is Required?File Handling is an integral part of any programming languag
6 min read
Java Method ReferencesIn Java, a method is a collection of statements that perform some specific task and return the result to the caller. A method reference is the shorthand syntax for a lambda expression that contains just one method call. In general, one does not have to pass arguments to method references.Why Use Met
9 min read
Java 8 Stream TutorialJava 8 introduces Stream, which is a new abstract layer, and some new additional packages in Java 8 called java.util.stream. A Stream is a sequence of components that can be processed sequentially. These packages include classes, interfaces, and enum to allow functional-style operations on the eleme
15+ min read
Java NetworkingWhen computing devices such as laptops, desktops, servers, smartphones, and tablets and an eternally-expanding arrangement of IoT gadgets such as cameras, door locks, doorbells, refrigerators, audio/visual systems, thermostats, and various sensors are sharing information and data with each other is
15+ min read
JDBC TutorialJDBC stands for Java Database Connectivity. JDBC is a Java API or tool used in Java applications to interact with the database. It is a specification from Sun Microsystems that provides APIs for Java applications to communicate with different databases. Interfaces and Classes for JDBC API comes unde
12 min read
Java Memory ManagementJava memory management is the process by which the Java Virtual Machine (JVM) automatically handles the allocation and deallocation of memory. It uses a garbage collector to reclaim memory by removing unused objects, eliminating the need for manual memory managementJVM Memory StructureJVM defines va
4 min read
Garbage Collection in JavaGarbage collection in Java is an automatic memory management process that helps Java programs run efficiently. Java programs compile to bytecode that can be run on a Java Virtual Machine (JVM). When Java programs run on the JVM, objects in the heap are created, which is a portion of memory dedicated
7 min read
Memory Leaks in JavaIn programming, a memory leak happens when a program keeps using memory but does not give it back when it's done. It simply means the program slowly uses more and more memory, which can make things slow and even stop working. Working of Memory Management in JavaJava has automatic garbage collection,
3 min read
Practice Java
Java Interview Questions and AnswersJava is one of the most popular programming languages in the world, known for its versatility, portability, and wide range of applications. Java is the most used language in top companies such as Uber, Airbnb, Google, Netflix, Instagram, Spotify, Amazon, and many more because of its features and per
15+ min read
Java Programs - Java Programming ExamplesIn this article, we will learn and prepare for Interviews using Java Programming Examples. From basic Java programs like the Fibonacci series, Prime numbers, Factorial numbers, and Palindrome numbers to advanced Java programs.Java is one of the most popular programming languages today because of its
8 min read
Java Exercises - Basic to Advanced Java Practice Programs with SolutionsLooking for Java exercises to test your Java skills, then explore our topic-wise Java practice exercises? Here you will get 25 plus practice problems that help to upscale your Java skills. As we know Java is one of the most popular languages because of its robust and secure nature. But, programmers
7 min read
Java Quiz | Level Up Your Java SkillsThe best way to scale up your coding skills is by practicing the exercise. And if you are a Java programmer looking to test your Java skills and knowledge? Then, this Java quiz is designed to challenge your understanding of Java programming concepts and assess your excellence in the language. In thi
1 min read
Top 50 Java Project Ideas For Beginners and Advanced [Update 2025]Java is one of the most popular and versatile programming languages, known for its reliability, security, and platform independence. Developed by James Gosling in 1982, Java is widely used across industries like big data, mobile development, finance, and e-commerce.Building Java projects is an excel
15+ min read