CopyOnWriteArrayList in Java

CopyOnWriteArrayList is a class introduced in JDK 1.5 that implements the List interface. It is an enhanced version of ArrayList in which all modifications (add, set, remove, etc.) are implemented by creating a fresh copy. It is found in the java.util.concurrent package and is designed to be used in a concurrent environment.

• Thread-safe version of ArrayList suitable for concurrent access.
• All update operations create a cloned copy of the underlying list.
• Iterators provide a snapshot and do not throw ConcurrentModificationException.

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {

        // Creating a CopyOnWriteArrayList
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

        // Adding elements
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // Printing the list
        System.out.println("CopyOnWriteArrayList elements: " + list);
    }
}

CopyOnWriteArrayList elements: [Java, Python, C++]

Explanation:This example demonstrates how to create a CopyOnWriteArrayList, add elements using add() method, and display the elements.

Hierarchy of CopyOnWriteArrayList

CopyOnWriteArrayList extends the Object class and implements List, RandomAccess, Cloneable, and Serializable interfaces in the java.util.concurrent package.

Declaration of CopyOnWriteArrayList

public class CopyOnWriteArrayList<E> extends Object implements List<E>, RandomAccess, Cloneable, Serializable

• Here, E is the type of elements held in this collection.
• The class implements Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess interfaces.

Constructors Of CopyOnWriteArrayList

1. CopyOnWriteArrayList():

Creates an empty list.

CopyOnWriteArrayList<String> c = new CopyOnWriteArrayList<>();

2. CopyOnWriteArrayList(Collection obj):

Creates a list containing the elements of the specified collection.

CopyOnWriteArrayList<String> c = new CopyOnWriteArrayList<>(collection);

3. CopyOnWriteArrayList(Object[] obj):

Creates a list holding a copy of the given array.

CopyOnWriteArrayList<String> c = new CopyOnWriteArrayList<>(array);

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class ConcurrentDemo extends Thread {

    static CopyOnWriteArrayList<String> l = new CopyOnWriteArrayList<>();

    public void run() {
        // Child thread adding new element
        l.add("D");
    }

    public static void main(String[] args) {

        l.add("A");
        l.add("B");
        l.add("C");

        ConcurrentDemo t = new ConcurrentDemo();
        t.start();

        // Iterating list
        Iterator<String> itr = l.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }

        System.out.println("Final List: " + l);
    }
}

A
B
C
Final List: [A, B, C, D]

Explanation:In this example, a child thread adds a new element to the CopyOnWriteArrayList while the main thread iterates over it. The iterator works on a snapshot of the list, so the modification does not affect the current iteration and no ConcurrentModificationException occurs.

Methods of CopyOnWriteArrayList:

Methods inherited from interface java.util.Collection: