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

Sanfoundry Global Education & Learning Series – 1000 Java Programs.

If you wish to look at all Java Programming examples, go to Java Programs.

If you find any mistake above, kindly email to [email protected]

« Prev - Java Program to Implement Stack API

» Next - Java Program to Implement JobStateReasons API

Related Posts:

Recommended Articles: