Comparing enums in Java involves checking if two enum constants are the same, and compare.edu.vn helps you understand the different ways to do this effectively, ensuring code clarity and correctness. By using methods like ==, equals(), and compareTo(), you can ensure that you make the right comparison. This article explores various comparison techniques, highlighting their nuances and providing practical examples to facilitate a clear understanding. Leverage advanced techniques, Java enum best practices, and efficient coding practices.
1. Understanding Java Enums
1.1 What are Enums in Java?
Enums, short for enumerations, are a special data type in Java used to represent a group of named constants. They are essentially classes that represent a fixed set of possible values.
Enums provide type safety, ensuring that a variable can only hold one of the defined constants. This helps prevent errors and makes code more readable. For example, you can define an enum for days of the week or status codes in an application.
1.2 Why Use Enums?
Using enums offers several benefits:
- Type Safety: Enums prevent the use of invalid values, enhancing the robustness of your code.
- Readability: Enums make code more self-documenting by using meaningful names for constants.
- Maintainability: Changes to the set of possible values are localized to the enum definition, reducing the risk of introducing bugs.
- Performance: Enum comparisons using
==are faster than comparing strings or integers because they compare references.
1.3 Basic Enum Declaration
An enum is declared using the enum keyword, followed by the enum name, and a list of constants. Here is a basic example:
enum Day {
SUNDAY,
MONDAY,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY
}In this example, Day is an enum with seven constants representing the days of the week.
2. Methods for Comparing Enums in Java
2.1 Using the == Operator
The most straightforward way to compare enums in Java is by using the == operator. This operator checks if two enum variables refer to the same instance.
Day day1 = Day.MONDAY;
Day day2 = Day.MONDAY;
if (day1 == day2) {
System.out.println("The days are the same.");
} else {
System.out.println("The days are different.");
}In this case, the output will be “The days are the same.” because day1 and day2 both refer to the same enum constant MONDAY.
2.2 Using the equals() Method
The equals() method is another way to compare enums. It is inherited from the Object class and is overridden by the Enum class to provide a meaningful comparison.
Day day1 = Day.MONDAY;
Day day2 = Day.MONDAY;
if (day1.equals(day2)) {
System.out.println("The days are the same.");
} else {
System.out.println("The days are different.");
}The equals() method behaves the same as the == operator for enums, ensuring that two enum variables refer to the same instance.
2.3 Using the compareTo() Method
The compareTo() method is part of the Comparable interface, which the Enum class implements. This method compares the ordinal values of the enum constants.
Day day1 = Day.MONDAY;
Day day2 = Day.WEDNESDAY;
int result = day1.compareTo(day2);
if (result < 0) {
System.out.println("day1 comes before day2.");
} else if (result > 0) {
System.out.println("day1 comes after day2.");
} else {
System.out.println("The days are the same.");
}In this example, the output will be “day1 comes before day2.” because MONDAY comes before WEDNESDAY in the enum declaration. The compareTo() method returns:
- A negative value if the first enum constant comes before the second.
- A positive value if the first enum constant comes after the second.
- Zero if the enum constants are the same.
3. Comparing Enums with Different Values
3.1 Basic Example
Consider an enum Status with constants OPEN, IN_PROGRESS, and CLOSED.
enum Status {
OPEN,
IN_PROGRESS,
CLOSED
}
Status status1 = Status.OPEN;
Status status2 = Status.CLOSED;
if (status1 == status2) {
System.out.println("The statuses are the same.");
} else {
System.out.println("The statuses are different.");
}In this case, the output will be “The statuses are different.” because status1 and status2 refer to different enum constants.
3.2 Using equals() Method
Similarly, using the equals() method will yield the same result.
Status status1 = Status.OPEN;
Status status2 = Status.CLOSED;
if (status1.equals(status2)) {
System.out.println("The statuses are the same.");
} else {
System.out.println("The statuses are different.");
}3.3 Using compareTo() Method
The compareTo() method will compare the ordinal values of OPEN and CLOSED.
Status status1 = Status.OPEN;
Status status2 = Status.CLOSED;
int result = status1.compareTo(status2);
if (result < 0) {
System.out.println("status1 comes before status2.");
} else if (result > 0) {
System.out.println("status1 comes after status2.");
} else {
System.out.println("The statuses are the same.");
}The output will be “status1 comes before status2.” because OPEN is declared before CLOSED in the enum.
4. Advanced Enum Comparisons
4.1 Enums with Fields and Methods
Enums can have fields and methods, allowing for more complex behavior. Consider an enum TrafficLight with a field for color and a method to get the duration.
enum TrafficLight {
RED("Red", 120),
YELLOW("Yellow", 30),
GREEN("Green", 120);
private final String color;
private final int duration;
TrafficLight(String color, int duration) {
this.color = color;
this.duration = duration;
}
public String getColor() {
return color;
}
public int getDuration() {
return duration;
}
}4.2 Comparing Enums Based on Fields
To compare enums based on their fields, you can write custom methods within the enum.
enum TrafficLight {
RED("Red", 120),
YELLOW("Yellow", 30),
GREEN("Green", 120);
private final String color;
private final int duration;
TrafficLight(String color, int duration) {
this.color = color;
this.duration = duration;
}
public String getColor() {
return color;
}
public int getDuration() {
return duration;
}
public boolean isSameDuration(TrafficLight other) {
return this.duration == other.duration;
}
}
TrafficLight light1 = TrafficLight.RED;
TrafficLight light2 = TrafficLight.GREEN;
if (light1.isSameDuration(light2)) {
System.out.println("The lights have the same duration.");
} else {
System.out.println("The lights have different durations.");
}In this example, the output will be “The lights have the same duration.” because both RED and GREEN have a duration of 120.
4.3 Using Custom Logic for Comparison
You can implement custom logic to compare enums based on specific criteria.
enum TrafficLight {
RED("Red", 120),
YELLOW("Yellow", 30),
GREEN("Green", 120);
private final String color;
private final int duration;
TrafficLight(String color, int duration) {
this.color = color;
this.duration = duration;
}
public String getColor() {
return color;
}
public int getDuration() {
return duration;
}
public boolean isLongerThan(TrafficLight other) {
return this.duration > other.duration;
}
}
TrafficLight light1 = TrafficLight.RED;
TrafficLight light2 = TrafficLight.YELLOW;
if (light1.isLongerThan(light2)) {
System.out.println("light1 is longer than light2.");
} else {
System.out.println("light1 is not longer than light2.");
}Here, the output will be “light1 is longer than light2.” because the duration of RED (120) is greater than the duration of YELLOW (30).
5. Best Practices for Enum Comparisons
5.1 Use == for Simple Equality Checks
For simple equality checks, the == operator is the most efficient and readable option. It directly compares the references of the enum constants.
5.2 Prefer equals() for Consistency
Although equals() behaves the same as == for enums, using it consistently throughout your code can improve readability and maintainability.
5.3 Use compareTo() for Ordering
When you need to determine the order of enum constants, the compareTo() method is the best choice. It provides a clear and concise way to compare ordinal values.
5.4 Implement Custom Methods for Complex Comparisons
For more complex comparisons based on fields or custom logic, implement custom methods within the enum. This encapsulates the comparison logic and makes the code more maintainable.
5.5 Avoid Using switch Statements with Enums
While switch statements can be used with enums, they can become verbose and difficult to maintain, especially as the enum grows. Consider using polymorphism or strategy patterns instead.
6. Common Mistakes to Avoid
6.1 Using != Instead of ==
While != can be used to check for inequality, it’s generally better to use == for equality checks and negate the result using ! for clarity.
6.2 Comparing Enums with Different Types
Ensure that you are comparing enums of the same type. Comparing enums of different types will always result in inequality and can lead to unexpected behavior.
6.3 Ignoring Case Sensitivity
Enum constant names are case-sensitive. Ensure that you are using the correct case when comparing enum constants.
6.4 Overcomplicating Simple Comparisons
Avoid using complex logic for simple equality checks. The == operator is sufficient for most cases.
6.5 Not Handling Null Values
When comparing enums that might be null, make sure to handle null values appropriately to avoid NullPointerException.
7. Practical Examples
7.1 Example 1: Comparing Days of the Week
enum Day {
SUNDAY,
MONDAY,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY
}
public class EnumComparisonExample {
public static void main(String[] args) {
Day today = Day.WEDNESDAY;
Day meetingDay = Day.MONDAY;
if (today == meetingDay) {
System.out.println("Today is the meeting day.");
} else {
System.out.println("Today is not the meeting day.");
}
if (today.compareTo(meetingDay) > 0) {
System.out.println("Today is after the meeting day.");
} else {
System.out.println("Today is before the meeting day.");
}
}
}In this example, we compare two Day enum constants to determine if they are the same and which one comes first.
7.2 Example 2: Comparing Task Statuses
enum TaskStatus {
PENDING,
IN_PROGRESS,
COMPLETED,
FAILED
}
public class TaskStatusExample {
public static void main(String[] args) {
TaskStatus currentStatus = TaskStatus.IN_PROGRESS;
TaskStatus targetStatus = TaskStatus.COMPLETED;
if (currentStatus.equals(targetStatus)) {
System.out.println("The task is completed.");
} else {
System.out.println("The task is not completed.");
}
if (currentStatus.compareTo(targetStatus) < 0) {
System.out.println("The current status is before the target status.");
} else {
System.out.println("The current status is after the target status.");
}
}
}Here, we compare TaskStatus enum constants to check the progress of a task.
7.3 Example 3: Comparing Traffic Light Durations
enum TrafficLight {
RED("Red", 120),
YELLOW("Yellow", 30),
GREEN("Green", 120);
private final String color;
private final int duration;
TrafficLight(String color, int duration) {
this.color = color;
this.duration = duration;
}
public String getColor() {
return color;
}
public int getDuration() {
return duration;
}
public boolean isSameDuration(TrafficLight other) {
return this.duration == other.duration;
}
}
public class TrafficLightExample {
public static void main(String[] args) {
TrafficLight light1 = TrafficLight.RED;
TrafficLight light2 = TrafficLight.GREEN;
if (light1.isSameDuration(light2)) {
System.out.println("The lights have the same duration.");
} else {
System.out.println("The lights have different durations.");
}
}
}This example demonstrates comparing TrafficLight enum constants based on their duration using a custom method.
8. Enums and Switch Statements
8.1 Using Switch Statements with Enums
Enums can be effectively used in switch statements to handle different cases based on the enum constant.
enum Signal {
GREEN,
YELLOW,
RED
}
public class SwitchEnumExample {
public static void main(String[] args) {
Signal currentSignal = Signal.YELLOW;
switch (currentSignal) {
case GREEN:
System.out.println("Go!");
break;
case YELLOW:
System.out.println("Prepare to stop!");
break;
case RED:
System.out.println("Stop!");
break;
default:
System.out.println("Invalid signal.");
}
}
}This example shows how to use a switch statement to handle different traffic signals.
8.2 Benefits of Using Enums with Switch Statements
- Readability: Enums make the
switchstatement more readable by using meaningful names for constants. - Type Safety: The compiler can check that the
switchstatement covers all possible enum constants, preventing errors. - Maintainability: Changes to the enum are automatically reflected in the
switchstatement, reducing the risk of introducing bugs.
8.3 Alternatives to Switch Statements
While switch statements are useful, they can become verbose and difficult to maintain as the enum grows. Alternatives include using polymorphism or strategy patterns.
9. Enums and Collections
9.1 Using Enums in Collections
Enums can be used as keys in Map collections to associate data with enum constants.
import java.util.HashMap;
import java.util.Map;
enum Role {
ADMIN,
USER,
GUEST
}
public class EnumMapExample {
public static void main(String[] args) {
Map<Role, String> rolePermissions = new HashMap<>();
rolePermissions.put(Role.ADMIN, "Full access");
rolePermissions.put(Role.USER, "Limited access");
rolePermissions.put(Role.GUEST, "Read-only access");
Role currentRole = Role.USER;
String permission = rolePermissions.get(currentRole);
System.out.println("Current role: " + currentRole);
System.out.println("Permission: " + permission);
}
}This example demonstrates how to use enums as keys in a Map to store role-based permissions.
9.2 EnumSet and EnumMap
Java provides specialized collections for enums called EnumSet and EnumMap. These collections are more efficient than generic Set and Map implementations when working with enums.
- EnumSet: A specialized
Setimplementation for enums that uses a bit vector to represent the set of enum constants. - EnumMap: A specialized
Mapimplementation for enums that uses an array to store the values associated with enum constants.
9.3 Example Using EnumSet
import java.util.EnumSet;
enum Permission {
READ,
WRITE,
EXECUTE
}
public class EnumSetExample {
public static void main(String[] args) {
EnumSet<Permission> adminPermissions = EnumSet.allOf(Permission.class);
EnumSet<Permission> userPermissions = EnumSet.of(Permission.READ, Permission.WRITE);
System.out.println("Admin permissions: " + adminPermissions);
System.out.println("User permissions: " + userPermissions);
if (adminPermissions.contains(Permission.EXECUTE)) {
System.out.println("Admin can execute.");
}
}
}This example shows how to use EnumSet to manage permissions for different roles.
10. Handling Null Enums
10.1 Checking for Null Values
When working with enums that might be null, it’s important to check for null values before performing any operations to avoid NullPointerException.
enum Option {
YES,
NO,
MAYBE
}
public class NullEnumExample {
public static void main(String[] args) {
Option selectedOption = null;
if (selectedOption != null) {
System.out.println("Selected option: " + selectedOption);
} else {
System.out.println("No option selected.");
}
}
}10.2 Using Optional to Handle Nullable Enums
The Optional class can be used to handle nullable enums more gracefully.
import java.util.Optional;
enum Option {
YES,
NO,
MAYBE
}
public class OptionalEnumExample {
public static void main(String[] args) {
Optional<Option> selectedOption = Optional.ofNullable(null);
selectedOption.ifPresent(option -> System.out.println("Selected option: " + option));
if (!selectedOption.isPresent()) {
System.out.println("No option selected.");
}
}
}This example uses Optional to handle a nullable Option enum.
10.3 Providing Default Values
Another approach is to provide a default value for the enum when it is null.
enum Option {
YES,
NO,
MAYBE,
UNKNOWN
}
public class DefaultEnumExample {
public static void main(String[] args) {
Option selectedOption = null;
if (selectedOption == null) {
selectedOption = Option.UNKNOWN;
}
System.out.println("Selected option: " + selectedOption);
}
}In this case, UNKNOWN is used as the default value when selectedOption is null.
11. Performance Considerations
11.1 Enum Comparison Performance
Enum comparisons using == are very efficient because they compare references. This is faster than comparing strings or integers.
11.2 EnumSet and EnumMap Performance
EnumSet and EnumMap provide excellent performance for working with enums in collections. They are more efficient than generic Set and Map implementations.
11.3 Avoiding Boxing and Unboxing
When using enums with collections, avoid boxing and unboxing by using specialized collections like EnumSet and EnumMap. This can improve performance significantly.
11.4 Caching Enum Values
If you need to perform frequent lookups of enum values, consider caching them to improve performance.
12. Real-World Use Cases
12.1 Representing States in a Finite State Machine
Enums are commonly used to represent states in a finite state machine.
enum State {
IDLE,
LOADING,
RUNNING,
STOPPED
}
public class StateMachineExample {
public static void main(String[] args) {
State currentState = State.IDLE;
switch (currentState) {
case IDLE:
System.out.println("System is idle.");
currentState = State.LOADING;
break;
case LOADING:
System.out.println("System is loading.");
currentState = State.RUNNING;
break;
case RUNNING:
System.out.println("System is running.");
currentState = State.STOPPED;
break;
case STOPPED:
System.out.println("System is stopped.");
break;
}
System.out.println("Current state: " + currentState);
}
}12.2 Representing HTTP Status Codes
Enums can be used to represent HTTP status codes.
enum HttpStatus {
OK(200, "OK"),
BAD_REQUEST(400, "Bad Request"),
UNAUTHORIZED(401, "Unauthorized"),
FORBIDDEN(403, "Forbidden"),
NOT_FOUND(404, "Not Found"),
INTERNAL_SERVER_ERROR(500, "Internal Server Error");
private final int code;
private final String message;
HttpStatus(int code, String message) {
this.code = code;
this.message = message;
}
public int getCode() {
return code;
}
public String getMessage() {
return message;
}
}
public class HttpStatusExample {
public static void main(String[] args) {
HttpStatus status = HttpStatus.OK;
System.out.println("Status code: " + status.getCode());
System.out.println("Status message: " + status.getMessage());
}
}12.3 Representing Database Column Types
Enums can be used to represent database column types.
enum ColumnType {
INTEGER,
VARCHAR,
BOOLEAN,
DATE
}
public class ColumnTypeExample {
public static void main(String[] args) {
ColumnType type = ColumnType.VARCHAR;
System.out.println("Column type: " + type);
}
}13. Integrating Enums with Databases
13.1 Storing Enums in Databases
Enums can be stored in databases as strings or integers. When storing enums as strings, the enum constant name is stored in the database. When storing enums as integers, the ordinal value of the enum constant is stored.
13.2 Using JPA Converters
JPA converters can be used to automatically convert enums to and from their database representation.
import javax.persistence.AttributeConverter;
import javax.persistence.Converter;
enum Status {
ACTIVE,
INACTIVE,
PENDING
}
@Converter(autoApply = true)
public class StatusConverter implements AttributeConverter<Status, String> {
@Override
public String convertToDatabaseColumn(Status status) {
if (status == null) {
return null;
}
return status.name();
}
@Override
public Status convertToEntityAttribute(String dbData) {
if (dbData == null) {
return null;
}
try {
return Status.valueOf(dbData);
} catch (IllegalArgumentException e) {
return null;
}
}
}This example shows how to use a JPA converter to store the Status enum as a string in the database.
13.3 Using Custom JDBC Types
Custom JDBC types can be used to map enums to specific database types.
14. Testing Enum Comparisons
14.1 Unit Testing Enum Comparisons
Unit tests should be written to ensure that enum comparisons are working correctly.
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
enum Color {
RED,
GREEN,
BLUE
}
public class ColorTest {
@Test
void testEnumComparison() {
Color color1 = Color.RED;
Color color2 = Color.RED;
Color color3 = Color.BLUE;
assertEquals(color1, color2);
assertNotEquals(color1, color3);
assertTrue(color1.compareTo(color3) < 0);
}
}This example shows how to write a unit test to verify enum comparisons.
14.2 Integration Testing Enums with Databases
Integration tests should be written to ensure that enums are correctly stored and retrieved from the database.
14.3 Using Mocking Frameworks
Mocking frameworks can be used to isolate enum comparisons during testing.
15. Benefits of Using Enums Over Constants
15.1 Type Safety
Enums provide type safety, ensuring that a variable can only hold one of the defined constants. This prevents the use of invalid values and reduces the risk of errors.
15.2 Readability
Enums make code more readable by using meaningful names for constants. This makes the code more self-documenting and easier to understand.
15.3 Maintainability
Changes to the set of possible values are localized to the enum definition, reducing the risk of introducing bugs.
15.4 Performance
Enum comparisons using == are faster than comparing strings or integers because they compare references.
15.5 Compile-Time Checking
The compiler can check that all possible enum constants are handled in switch statements, preventing errors.
16. Advanced Enum Features
16.1 Implementing Interfaces
Enums can implement interfaces to provide common behavior across different enum types.
interface Codeable {
int getCode();
}
enum ErrorCode implements Codeable {
OK(200),
BAD_REQUEST(400),
INTERNAL_SERVER_ERROR(500);
private final int code;
ErrorCode(int code) {
this.code = code;
}
@Override
public int getCode() {
return code;
}
}
public class InterfaceEnumExample {
public static void main(String[] args) {
ErrorCode errorCode = ErrorCode.BAD_REQUEST;
System.out.println("Error code: " + errorCode.getCode());
}
}16.2 Using Abstract Methods
Enums can define abstract methods that must be implemented by each enum constant.
enum Operation {
ADD {
@Override
public int apply(int x, int y) {
return x + y;
}
},
SUBTRACT {
@Override
public int apply(int x, int y) {
return x - y;
}
};
public abstract int apply(int x, int y);
}
public class AbstractMethodEnumExample {
public static void main(String[] args) {
int x = 10;
int y = 5;
System.out.println("Add: " + Operation.ADD.apply(x, y));
System.out.println("Subtract: " + Operation.SUBTRACT.apply(x, y));
}
}16.3 Using Static Methods
Enums can define static methods to provide utility functions.
enum Planet {
MERCURY(3.303e+23, 2.4397e6),
VENUS(4.869e+24, 6.0518e6),
EARTH(5.976e+24, 6.37814e6);
private final double mass;
private final double radius;
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
public double getMass() {
return mass;
}
public double getRadius() {
return radius;
}
public static final double G = 6.67300E-11;
double surfaceGravity() {
return G * mass / (radius * radius);
}
double surfaceWeight(double mass) {
return mass * surfaceGravity();
}
}
public class StaticMethodEnumExample {
public static void main(String[] args) {
double earthWeight = 70;
double mass = earthWeight / Planet.EARTH.surfaceGravity();
for (Planet p : Planet.values()) {
System.out.printf("Weight on %s: %f%n", p, p.surfaceWeight(mass));
}
}
}17. Java Enum Limitations
17.1 Inheritance
Enums cannot inherit from other classes or enums. This can be a limitation when you need to share common behavior across multiple enum types.
17.2 Instantiation
Enums cannot be instantiated directly. This means that you cannot create new enum constants at runtime.
17.3 Serialization
Enums are automatically serialized by name, which can be a problem if you need to change the enum constant names.
17.4 Extensibility
Enums cannot be extended. This means that you cannot add new enum constants to an existing enum at runtime.
18. Alternatives to Enums
18.1 Using Constants
Constants can be used as an alternative to enums. However, constants do not provide type safety and can lead to errors.
18.2 Using Classes with Static Fields
Classes with static fields can be used to represent a fixed set of values. However, this approach is less type-safe than using enums.
18.3 Using Lookup Tables
Lookup tables can be used to map values to their corresponding representations. However, this approach can be less efficient than using enums.
19. Enum Design Patterns
19.1 Singleton Enum
Enums can be used to implement the singleton pattern.
enum Configuration {
INSTANCE;
private String setting;
Configuration() {
setting = "default value";
}
public String getSetting() {
return setting;
}
public void setSetting(String setting) {
this.setting = setting;
}
}
public class SingletonEnumExample {
public static void main(String[] args) {
Configuration config = Configuration.INSTANCE;
System.out.println("Setting: " + config.getSetting());
config.setSetting("new value");
System.out.println("Setting: " + config.getSetting());
}
}19.2 Strategy Enum
Enums can be used to implement the strategy pattern.
interface PaymentStrategy {
void pay(int amount);
}
enum PaymentType implements PaymentStrategy {
CREDIT_CARD {
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using credit card.");
}
},
PAYPAL {
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using PayPal.");
}
};
}
public class StrategyEnumExample {
public static void main(String[] args) {
PaymentType paymentType = PaymentType.CREDIT_CARD;
paymentType.pay(100);
}
}19.3 State Enum
Enums can be used to implement the state pattern.
interface State {
void handle(Context context);
}
enum ConcreteStateA implements State {
INSTANCE {
@Override
public void handle(Context context) {
System.out.println("State A");
context.setState(ConcreteStateB.INSTANCE);
}
}
}
enum ConcreteStateB implements State {
INSTANCE {
@Override
public void handle(Context context) {
System.out.println("State B");
context.setState(ConcreteStateA.INSTANCE);
}
}
}
class Context {
private State state;
public Context() {
state = ConcreteStateA.INSTANCE;
}
public void setState(State state) {
this.state = state;
}
public void request() {
state.handle(this);
}
}
public class StateEnumExample {
public static void main(String[] args) {
Context context = new Context();
context.request();
context.request();
}
}20. FAQs About Enum Comparisons in Java
20.1 Why should I use enums instead of constants?
Enums provide type safety, readability, and maintainability benefits over constants, reducing the risk of errors and improving code clarity.
20.2 How do I compare enums in Java?
You can compare enums using the == operator, the equals() method, or the compareTo() method. The == operator and equals() method check if two enum variables refer to the same instance, while the compareTo() method compares the ordinal values of the enum constants.
20.3 Can I add fields and methods to enums?
Yes, enums can have fields and methods, allowing for more complex behavior and custom comparisons based on specific criteria.
20.4 What are EnumSet and EnumMap?
EnumSet and EnumMap are specialized collection implementations for enums that provide better performance and efficiency compared to generic Set and Map implementations.
20.5 How do I handle null enums?
You can handle null enums by checking for null values before performing any operations
