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
Related posts:
Java Program to Remove the Edges in a Given Cyclic Graph such that its Linear Extension can be Found
Mapping Nested Values with Jackson
Send email with authentication
Using Spring @ResponseStatus to Set HTTP Status Code
Check if there is mail waiting
Object Type Casting in Java
Quick Guide on Loading Initial Data with Spring Boot
HttpClient 4 – Send Custom Cookie
Java Program to Implement Suffix Array
Hướng dẫn Java Design Pattern – Command
Lập trình đa luồng trong Java (Java Multi-threading)
Java – Try with Resources
Java – Reader to InputStream
Java InputStream to String
Spring MVC + Thymeleaf 3.0: New Features
Các nguyên lý thiết kế hướng đối tượng – SOLID
Java Program to Perform Searching in a 2-Dimension K-D Tree
Spring Security and OpenID Connect
Tìm hiểu về xác thực và phân quyền trong ứng dụng
Java Program to Implement Radix Sort
Spring Webflux with Kotlin
Consuming RESTful Web Services
Prevent Brute Force Authentication Attempts with Spring Security
Java – File to Reader
Java Program to Implement TreeMap API
Java Program to subtract two large numbers using Linked Lists
Một số tính năng mới về xử lý ngoại lệ trong Java 7
Java Program to Generate N Number of Passwords of Length M Each
Remove the First Element from a List
Java Program to Implement Adjacency Matrix
Case-Insensitive String Matching in Java
Java Program to Perform Inorder Recursive Traversal of a Given Binary Tree