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 internal workings of `CopyOnWriteArrayList` is a very important topic for Java interviews. In this lesson, we will see how `CopyOnWriteArrayList` provides thread-safety. 

> `CopyOnWriteArrayList` is internally backed by an array, so let’s call it **backarray** for the purpose of understanding. Throughout this lesson, wherever we use the term **backarray**, it means the array in which all the elements added to the `CopyOnWriteArrayList` is maintained.

There is a ReentrantLock defined in the `CopyOnWriteArrayList` as shown below:

```Java
/** The lock protecting all mutators */
final transient ReentrantLock lock = new ReentrantLock();
```
When a new element is added in a `CopyOnWriteArrayList` then the following procedure takes place:
 1. The thread that is adding the element acquires a lock on the `lock` object using the `lock.lock()` method. If some other thread tries to add an element to the list, then it will not get access.
2. The thread that has acquired the lock will then make the copy of the **backarray**. So as shown in the below snippet, a new array is created and all the elements from the **backarray** are added to this new array. The size of this new array is one more than the **backarray**.
```Java
Object[] newElements = Arrays.copyOf(elements, len + 1);
```
3. Now, the element that needs to be added will be added at the end of this newly copied array.

```Java
newElements[len] = e;
```
3. Finally the **backarray** will now be pointed to this new array and the lock will be released. In this way, a new element is added to the `CopyOnWriteArrayList` in a thread-safe manner.

Let's discuss the internal workings of CopyOnWriteArrayList.


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

CopyOnWriteArrayList: Internal Working