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

How **HashMap** works internally is the most asked interview question in Java interviews. And the reason is that it is difficult to understand the inner workings of **HashMap**. In this lesson, we will try to understand every aspect of **HashMap**.

The basic principle used by a HashMap to store elements is **Hashing**. Hashing is a way to assign a unique code for any variable or object after applying any formula to its properties.
The unique code is called **HashCode**.

Some of the properties of HashCode are:

1. If two objects are equal, then they should have the same hashcode.
2. If two objects have the same hashcode, then it is not necessary for them to be equal.

# Creating a HashMap
We already know that the **HashMap** stores key-value pairs. **HashMap** has a nested static class called **Node** as shown below.

```Java
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
...some more code
```

This class has a **key** and a **value** field. It also has a **next** field that is used to point to the next **Node**.

**HashMap** also has a field called table as shown below. It is basically an array of **Node** objects that are not yet initialized.

```Java
transient Node<K,V>[] table;
```

When we create a HashMap using the no-arg constructor, then the only thing that happens is that the **loadFactor** is assigned `DEFAULT_LOAD_FACTOR`, which is $.75$.

The **table** array that we discussed above is not initialized at the time of the creation of HashMap.

```Java
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
```

# Inserting into a HashMap

When an element is inserted into the **Hashmap** for the first time, the array **table** is initialized with size 16. So now there are 16 buckets from index 0 to 15.

If the key that we are inserting is null, then it is inserted at index 0 because the hashcode of null is 0. If the key is not null, then the hash of the **key** is calculated, and based on the hash value the bucket is decided.

If there is no other element in that bucket, then a new Node is created, and it is inserted in that bucket.


Let's look at how HashMap works internally.

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

HashMap: Internal Implementation