Java Program to Implement CopyOnWriteArrayList API

This Java program Implements CopyOnWriteArrayList API.A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.

Here is the source code of the Java Program to Implement CopyOnWriteArrayList API.The Java program is successfully compiled and run on a Linux system. The program output is also shown below.

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
 
public class CopyOnWriteArrayListImpl<E>
{
    private CopyOnWriteArrayList<E> copyOnWriteArrayList;
 
    /** Creates an empty list. **/
    public CopyOnWriteArrayListImpl()
    {
        copyOnWriteArrayList = new CopyOnWriteArrayList<>();
    }
 
    /**
     * Creates a list containing the elements of the specified collection, in
     * the order they are returned by the collection's iterator.
     **/
    public CopyOnWriteArrayListImpl(Collection<? extends E> c)
    {
        copyOnWriteArrayList = new CopyOnWriteArrayList<E>(c);
    }
 
    /** Creates a list holding a copy of the given array. **/
    public CopyOnWriteArrayListImpl(E[] tocopyIn)
    {
        copyOnWriteArrayList = new CopyOnWriteArrayList<E>(tocopyIn);
    }
 
    /** Appends the specified element to the end of this list. **/
    public boolean add(E e)
    {
        return copyOnWriteArrayList.add(e);
    }
 
    /** Inserts the specified element at the specified position in this list. **/
    public void add(int index, E element)
    {
        copyOnWriteArrayList.add(index, element);
    }
 
    /**
     * Appends all of the elements in the specified collection to the end of
     * this list, in the order that they are returned by the specified
     * collection's iterator.
    **/
    public boolean addAll(Collection<? extends E> c)
    {
        return copyOnWriteArrayList.addAll(c);
    }
 
    /**
     * Inserts all of the elements in the specified collection into this list,
     * starting at the specified position.
    **/
    public boolean addAll(int index, Collection<? extends E> c)
    {
        return copyOnWriteArrayList.addAll(index, c);
    }
 
    /**
     * Appends all of the elements in the specified collection that are not
     * already contained in this list, to the end of this list, in the order
     * that they are returned by the specified collection's iterator.
    **/
    public int addAllAbsent(Collection<? extends E> c)
    {
        return copyOnWriteArrayList.addAllAbsent(c);
    }
 
    /** Append the element if not present. **/
    public boolean addIfAbsent(E e)
    {
        return copyOnWriteArrayList.addIfAbsent(e);
    }
 
    /** Removes all of the elements from this list. **/
    public void clear()
    {
        copyOnWriteArrayList.clear();
    }
 
    /** Returns a shallow copy of this ArrayList instance. **/
    public Object clone()
    {
        return copyOnWriteArrayList.clone();
    }
 
    /** Returns true if this list contains the specified element. **/
    public boolean contains(Object o)
    {
        return copyOnWriteArrayList.contains(o);
    }
 
    /** Returns the element at the specified position in this list. **/
    public E get(int index)
    {
        return copyOnWriteArrayList.get(index);
    }
 
    /**
     * Returns the index of the first occurrence of the specified element in
     * this list, or -1 if this list does not contain the element.
    **/
    public int indexOf(Object o)
    {
        return copyOnWriteArrayList.indexOf(o);
    }
 
    /** Returns true if this list contains no elements. **/
    public boolean isEmpty()
    {
        return copyOnWriteArrayList.isEmpty();
    }
 
    /** Returns an iterator over the elements in this list in proper sequence. **/
    public Iterator<E> iterator()
    {
        return copyOnWriteArrayList.iterator();
    }
 
    /**
     * Returns the index of the last occurrence of the specified element in this
     * list, or -1 if this list does not contain the element.
    **/
    public int lastIndexOf(Object o)
    {
        return copyOnWriteArrayList.lastIndexOf(o);
    }
 
    /**
     * Returns a list iterator over the elements in this list (in proper
     * sequence).
    **/
    public ListIterator<E> listIterator()
    {
        return copyOnWriteArrayList.listIterator();
    }
 
    /**
     * Returns a list iterator over the elements in this list (in proper
     * sequence), starting at the specified position in the list.
    **/
    public ListIterator<E> listIterator(int index)
    {
        return copyOnWriteArrayList.listIterator(index);
    }
 
    /** Removes the element at the specified position in this list. **/
    public E remove(int index)
    {
        return copyOnWriteArrayList.remove(index);
    }
 
    /**
     * Removes the first occurrence of the specified element from this list, if
     * it is present.
    **/
    public boolean remove(Object o)
    {
        return copyOnWriteArrayList.remove(o);
    }
 
    /**
     * Removes from this list all of its elements that are contained in the
     * specified collection.
    **/
    public boolean removeAll(Collection<?> c)
    {
        return copyOnWriteArrayList.removeAll(c);
    }
 
    /**
     * Retains only the elements in this list that are contained in the
     * specified collection.
    **/
    public boolean retainAll(Collection<?> c)
    {
        return copyOnWriteArrayList.removeAll(c);
    }
 
    /**
     * Replaces the element at the specified position in this list with the
     * specified element.
    **/
    public E set(int index, E element)
    { 
        return copyOnWriteArrayList.set(index, element);
    }
 
    /** Returns the number of elements in this list. **/
    public int size()
    {
        return copyOnWriteArrayList.size();
    }
 
    /**
     * Returns a view of the portion of this list between the specified
     * fromIndex, inclusive, and toIndex, exclusive.
    **/
    public List<E> subList(int fromIndex, int toIndex)
    {
        return copyOnWriteArrayList.subList(fromIndex, toIndex);
    }
 
    /**
     * Returns an array containing all of the elements in this list in proper
     * sequence (from first to last element).
    **/
    public Object[] toArray()
    {
        return copyOnWriteArrayList.toArray();
    }
 
    /**
     * Returns an array containing all of the elements in this list in proper
     * sequence (from first to last element); the runtime type of the returned
     * array is that of the specified array.
    **/
    public <T> T[] toArray(T[] a)
    {
        return copyOnWriteArrayList.toArray(a);
    }
 
    public static void main(String...arg)
    {
        CopyOnWriteArrayListImpl<Integer> copyOnWriteArrayList = new CopyOnWriteArrayListImpl<Integer>();
        copyOnWriteArrayList.add(10);
        copyOnWriteArrayList.add(20);
        copyOnWriteArrayList.add(30);
        copyOnWriteArrayList.add(3, 40);
        copyOnWriteArrayList.add(-10);
 
        Set<Integer> addAll = new HashSet<Integer>();
        addAll.add(101);
        addAll.add(200);
        addAll.add(300);
        copyOnWriteArrayList.addAll(addAll);
 
        Set<Integer> indexAddAll = new HashSet<Integer>();
        indexAddAll.add(101);
        indexAddAll.add(102);
        indexAddAll.add(103);
        copyOnWriteArrayList.addAll(5, indexAddAll);
 
        if (copyOnWriteArrayList.contains(101))
            System.out.println("the copyOnWriteArrayList contains 101");
        else
            System.out.println("the copyOnWriteArrayList does not contain 101");
 
        System.out.println("the copyOnWriteArrayList contains " + copyOnWriteArrayList.get(5)
            + " at index 5");
        System.out.println("the index of 101 is " + copyOnWriteArrayList.indexOf(101));
        System.out.println("the elements of copyOnWriteArrayList are");
        Iterator<Integer> itr = copyOnWriteArrayList.iterator();
        while (itr.hasNext())
        {
            System.out.print(itr.next() + "\t");
        }
        System.out.println();
 
        System.out.println("the last index of 101 is " + copyOnWriteArrayList.lastIndexOf(101));
        System.out.println("elements from index 3 are");
        ListIterator<Integer> listIterator = copyOnWriteArrayList.listIterator(3);
        while (listIterator.hasNext())
        {
            System.out.print(listIterator.next() + "\t");
        }
        System.out.println();
 
        // removes element at index 5
        copyOnWriteArrayList.remove(5);
        System.out.println("elements removed and retained");
        Set<Integer> removeAll = new HashSet<Integer>();
        removeAll.add(30);
        removeAll.add(300);
        removeAll.add(101);
        copyOnWriteArrayList.removeAll(removeAll);
 
        Set<Integer> retainAll = new HashSet<Integer>();
        retainAll.add(10);
        retainAll.add(20);
        retainAll.add(200);
        retainAll.add(-10);
        retainAll.addAll(addAll);
 
        copyOnWriteArrayList.retainAll(retainAll);
        copyOnWriteArrayList.set(1, 101);
        System.out.println("the size of the copyOnWriteArrayList is " + copyOnWriteArrayList.size());
        System.out.println("the elements of the returned list are");
        List<Integer> list = copyOnWriteArrayList.subList(0,1);
        for (int i = 0; i < list.size(); i++)
        {
            System.out.println(list.get(i) + "\t");
        }
        System.out.println();
        System.out.println("the elements of returned array are");
        Object[] array = (Object[]) copyOnWriteArrayList.toArray();
        for (int i = 0; i < array.length; i++)
        {
            System.out.print(array[i] + "\t");
        }
        System.out.println();
        System.out.println("the size of the copyOnWriteArrayList is " + copyOnWriteArrayList.size());
        copyOnWriteArrayList.clear();
        if (copyOnWriteArrayList.isEmpty())
            System.out.println("the copyOnWriteArrayList is empty");
        else
            System.out.println("the copyOnWriteArrayList is not empty");
    }
}

$ javac CopyOnWriteArrayListImpl.java
$ java CopyOnWirteArrayListImpl
the copyOnWriteArrayList contains 101
the copyOnWriteArrayList contains 102 at index 5
the index of 101 is 7
the elements of copyOnWriteArrayList are
10	20	30	40	-10	102	103	101	101	200	300	
the last index of 101 is 8
elements from index 3 are
40	-10	102	103	101	101	200	300	
elements removed and retained
the size of the copyOnWriteArrayList is 2
the elements of the returned list are
40	
 
the elements of returned array are
40	101	
the size of the copyOnWriteArrayList is 2
the copyOnWriteArrayList is empty