Gain insights into Java Collections Framework. Delve into lists, sets, and hashmaps. Learn about data modification, sorting, thread-safety, and internal workings for efficient usage.

Collection is one of the most important topics for Java programming. Without the proper knowledge of every collection type in Java, it becomes difficult for you to decide which option to pick in a particular scenario.

This course will give you a great understanding of all collection types available in the Collections Framework like lists, linked lists, sets, and hashmaps. 

After completing this course, you will know how data can be modified within a collection, how to sort a collection, and how it can be made thread-safe. You will also cover the internal working of each Java collection so you can work with them more efficiently.

Collections in Java

The **EnumMap** is a special kind of Map in which the keys are only of the **Enum** type. Although it is possible to use the Enum type as a key in other Map implementations such as a HashMap or TreeMap, but a separate Map implementation was created for performance reasons.

The **EnumMap** is highly efficient, and we will discuss more when we will look at how it works internally. Let's look at some of the features of **EnumMap**.

1. **EnumMap** does not allow null keys, but it allows null values.
2. The keys are stored in their natural order. In the case of an **Enum**, the natural order of keys means the order where enum constant is declared inside Enum type.
3. The **EnumMap** is not synchronized.
4. All keys of each **EnumMap** instance must be keys of a single Enum type.
5. Iterators returned by the collection views are inconsistent. 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.
6. Java **EnumMap** implementation provides constant-time performance for the basic operations (like get and put).

# Internal workings of an EnumMap

When an **EnumMap** instance is created, it is mandatory to pass the type of Enum that will be stored in this EnumMap. When we create the instance, then two arrays, **keyUniverse** and **vals**, are initialized. The size of both these arrays is equal to the number of elements in the Enum. The **keyUniverse** array stores the elements of the Enum, and **vals** array stores the values corresponding to the keys. The _ith_ element is the value to which universe[i] is currently mapped, it's null if it isn't mapped to anything, or NULL if it's mapped to null.

When an element is inserted into an **EnumMap**, the index of the element that is being inserted is calculated. Let's say we have an Enum as shown below:

```Java
public enum FRUITS {
       APPLE, BANANA, ORANGE
}
```
If we try to store **BANANA** in the **EnumMap**, the index of **BANANA** is 1. So the value will be stored at `vals[1]`.

Similarly, if we need to get a value for a key, then we will get the index of that key and then get the value using the `vals[index]` method.

As you can see, there is no need to calculate any hashcode in an **EnumMap**, and each bucket contains only one element. This makes it very efficient compared to a HashMap.

# Creating an EnumMap
There are three constructors available to create an instance of an **EnumMap**. Let's discuss all three of them.

## Constructor taking the key type as input

There is no no-arg constructor in **EnumMap** because while creating an **EnumMap**, the type of the Enum that will be stored must be known. The reason is that based on the number of fields in the Enum, the array size is decided while. So, this constructor takes the type of Enum as input. The syntax of creating an **EnumMap**. So this constructor takes the type of Enum as input. The syntax of creating an **EnumMap** using this constructor is as seen below:
```Java
EnumMap<DayOfWeek, Integer> enumMap = new EnumMap<>(DayOfWeek.class);
```

## Constructor taking another **EnumMap** as parameter
When an **EnumMap** is created using another **EnumMap**, then an enum map is created with the same key type as the specified **EnumMap**, initially containing the same mappings (if any). The **EnumMap** that is passed as a parameter can be empty.

## Constructor taking another Map as a parameter
This creates an enum map initialized from the specified map. If the specified map is an **EnumMap** instance, this constructor behaves identically to the constructor discussed above. Otherwise, the specified map must contain at least one mapping (in order to determine the new enum map's key type).

All other operations such as insert, fetch, update, etc., are the same as the other Map implementations. We will now look at an example.

In the below example, we have created a DayOfWeek Enum that will be used to store the week's day and how many hours a person worked on that day. 

Let's Begin

Lists in Java

LinkedList in Java

CopyOnWriteArrayList in Java

Sets in Java

TreeSet in Java

HashMap In Java

TreeMap in Java

LinkedHashMap in Java

Additional Map Implementations

Arrays Class

Collections Class

EnumMap