JDK collection source ArrayList parsing (with interview questions)

Cloneable interface can be shallow copy

 /** * Returns a shallow copy of this <tt>ArrayList</tt> instance. (The * elements themselves are not copied.) ArrayList </ tt> copy of an instance. (The element itself is not copied.) * *@return a clone of this <tt>ArrayList</tt> instance
  */
 public Object clone(a) {
     try{ ArrayList<? > v = (ArrayList<? >)super.clone();
         / / copy
         v.elementData = Arrays.copyOf(elementData, size);
         v.modCount = 0;
         return v;
     } catch (CloneNotSupportedException e) {
         // this shouldn't happen, since we are Cloneable
         throw newInternalError(e); }}Copy the code

In The Java language, objects can be deep-copied or shallow-copied when implementing the Cloneable interface. Here are the differences between deep-copied and shallow-copied objects:

First create a User class:

/ * * *@Auther: csp1999
 * @Date: 2020/10/28/15:51
 * @Description: * /
public class User {
    private String name;/ / user name
    public String getName(a) {returnname; }public void setName(String name) {this.name = name; }
    public User(String name) { this.name = name; }public User(a) {}
    @Override
    public String toString(a) {
        return "User{" +
                "name='" + name + '\' ' +
                '} '; }}Copy the code

Here’s an example of a shallow copy:

@Test
public void test02(a) {
    /** * simple demonstration of ArrayList shallow copy: */
    ArrayList list = new ArrayList();
    // Instantiate the User object
    User user = new User("csp");
    list.add("abc");// list adds simple character types
    list.add(user);// list Adds the object type
    System.out.println("------------ Original ArrayList collection ------------");
    System.out.println("list:"+list);
    / / shallow copy
	ArrayList clone = (ArrayList) list.clone();
	System.out.println("------------ New ArrayList collection after shallow copy ------------");
	System.out.println("Are the addresses the same:" + (list == clone));
	System.out.println("------------ before modifying the User attribute in list ------------");
	System.out.println("clone:"+clone);
	System.out.println("------------ after modifying the User attribute in the list ------------");
	User u = (User) list.get(1);
	u.setName("csp1999");
	System.out.println("clone:"+clone);
	System.out.println(Clone user object address is the same as the original list user object address:+(list.get(1)==clone.get(1)));
}
Copy the code

Output result:

-- -- -- -- -- -- -- -- -- -- -- -- original ArrayList collection -- -- -- -- -- -- -- -- -- -- -- -- the list: [ABC, User {name = 'CSP'}] -- -- -- -- -- -- -- -- -- -- -- -- shallow copy after new ArrayList collection -- -- -- -- -- -- -- -- -- -- -- -- the two address is the same: False -- -- -- -- -- -- -- -- -- -- -- -- not to modify the list of User attributes before -- -- -- -- -- -- -- -- -- -- -- -- clone: [ABC, User {name = 'CSP'}] -- -- -- -- -- -- -- -- -- -- -- -- after modify User attributes of the list -- -- -- -- -- -- -- -- -- -- -- -- clone: [ABC, Clone User{name='csp1999'}] Check whether the address of the User object is the same as that of the original list: trueCopy the code

It can be concluded from the results that:

• When the original list collection is cloned, a new one is actually createdArrayListObject with different address references
• When the user object is obtained from the list set and its attributes are modified, the user attribute in the Clone set is also changed accordingly. This indicates that when Clone copies the list set, it only copies the address reference of the complex object type data elements without creating new objects
• Therefore, the implementationlist.get(1)==clone.get(1))At the time of the code, both stores the same User object with the same address and data

In the case of deep copy, when the list is cloned to create new cloned objects, the complex object types stored in the list are also created. The complex object type data obtains new address references, instead of copying only the address references of the complex object types as in the shallow copy. \

ArrayList implements the RandomAccess interface, so random lists can be accessed more efficiently than sequential lists. Let’s look at an example:

@Test
public void test03(a) {
    ArrayList arrayList = new ArrayList();
    for (int i=0; i<=99999; i++){// Add 100000 data to the collection
        arrayList.add(i);
    }
    // Test random access efficiency:
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < arrayList.size(); i++) {// Random access
        // Access each element from the collection
        arrayList.get(i);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Time to perform random access:"+(endTime-startTime));
    // Test the efficiency of sequential access:
    startTime = System.currentTimeMillis();
    Iterator it = arrayList.iterator();// Sequential access, enhanced for can also be used
    while (it.hasNext()){
        // Access each element from the collection
        it.next();
    }
    endTime = System.currentTimeMillis();
    System.out.println("Time to perform sequential access:"+(endTime-startTime));
}
Copy the code

View the output:

Time used for random access: 1 Time used for sequential access: 3Copy the code

You can see that an ArrayList implementing the RandomAccess interface is more efficient for RandomAccess than for sequential access. For comparison, let’s take a look at a collection of LinkedLists that do not implement the RandomAccess interface to test the efficiency of randomly and sequentially accessed lists:

@Test
public void test04(a) {
    LinkedList linkedList = new LinkedList();
    for (int i=0; i<=99999; i++){// Add 100000 data to the collection
        linkedList.add(i);
    }
    // Test random access efficiency:
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < linkedList.size(); i++) {// Random access
        // Access each element from the collection
        linkedList.get(i);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Time to perform random access:"+(endTime-startTime));
    // Test the efficiency of sequential access:
    startTime = System.currentTimeMillis();
    Iterator it = linkedList.iterator();// Sequential access, enhanced for can also be used
    while (it.hasNext()){
        // Access each element from the collection
        it.next();
    }
    endTime = System.currentTimeMillis();
    System.out.println("Time to perform sequential access:"+(endTime-startTime));
}
Copy the code

View the output:

Time used for random access: 4601 Time used for sequential access: 2Copy the code

It can be concluded from the results that the efficiency of testing RandomAccess is much lower than sequential access without implementing the collection of LinkedList interface.

\

ArrayList(int initialCapacity) has a parameter constructor

/** * Constructs an empty list with the specified initial capacity. * Constructs an empty list with the specified initial capacity@paramInitialCapacity The initial capacity of the list Initial capacity *@throwsIllegalArgumentException if the specified Initial capacity is negative * * Use the EMPTY_ELEMENTDATA empty array if it is 0, and throw an exception if it is less than 0. * /
// ArrayList(int initialCapacity) constructor
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Unreasonable capacity of first knowledge:"+ initialCapacity); }}Copy the code

ArrayList() empty argument constructor

 Constructs an empty list with an initial capacity of ten ** Constructs an empty list with an initial capacity of ten ** Constructs an empty list with an initial capacity of ten Initialize to DEFAULTCAPACITY_EMPTY_ELEMENTDATA, and the * will be expanded to the default size of 10 when the first element is added. * /
 public ArrayList(a) {
     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 }
Copy the code

ArrayList(Collection C) has parameter constructors

/** * Constructs a list containing the elements of the specified * collection, In the order they are returned by the collection's * iterator@param c the collection whose elements are to be placed into this list
 * @throws NullPointerException if the specified collection is null
 */
public ArrayList(Collection<? extends E> c) {
    // Convert the collection arguments in the constructor to arrays
    elementData = c.toArray();
    if((size = elementData.length) ! =0) {
        // Check whether c. toarray () returns an Object[]. If not, copy it back to Object[]. Class
        if(elementData.getClass() ! = Object[].class)// Create and copy an array
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // If c is an empty collection, initialize the empty array EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA; }}Copy the code

Question: Why check to see if c. toarray () returns Object[] and copy it to Object[]. Class? First of all, we all know that Object is a super superclass in Java. All classes inherit from Object indirectly or directly. Let’s look at an example:

/ * * *@Auther: csp1999
 * @Date: 2020/10/27 / "*@Description: * /
public class ArrayListTest {
    class Father {}
    class Son extends Father {}
    class MyList extends ArrayList<String> {
        /** * subclass overrides the method of the parent class. The return value can be different, but only the array type can be used. * Object does not work
        @Override
        public String[] toArray() {
            // Write to death for example
            return new String[]{"a"."b"."c"}; }}@Test
    public void test01(a) {
        Father[] fathers = new Son[]{};
        / / print the results as follows: the class [Lcom. Haust. Test. ArrayListTest $Son;
        System.out.println(fathers.getClass());

        List<String> strList = new MyList();
        // Prints the result: class [ljava.lang.String;System.out.println(strList.toArray().getClass()); }}Copy the code

Adding elements to the end takes O(1) on average:

 /** * Appends the specified element to the end of this list@param e element to be appended to this list
 * @return <tt>true</tt> (as specified by {@link Collection#add})
  */
 public boolean add(E e) {
     // For each element added, minCapacity is +1 and check whether it needs to be expanded
     ensureCapacityInternal(size + 1);  // Increments modCount!!
     // Insert the element to the last digit
     elementData[size++] = e;
     return true;
 }
// Calculate the minimum capacity
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // Return the larger part of DEFAULT_CAPACITY and minCapacity
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}
// Check whether the capacity needs to be expanded
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;// The number of times the array structure is modified +1
    // Overflow-conscious code stores elements with a size smaller than the required minimum
    if (minCapacity - elementData.length > 0)
        / / capacity
        grow(minCapacity);
}
/** * Increases the capacity to ensure that it can hold at lea * number of elements specified by the minimum Capacity ARg * Increments the capacity to ensure that it can hold at least the number of elements specified by the minimum capacity parameter *@param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
    // The original capacity
    int oldCapacity = elementData.length;
    // The new capacity is 1.5 times the old capacity
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // If the new capacity is found to be smaller than the required capacity, the required capacity prevails
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // If the new capacity exceeds the maximum capacity, use the maximum capacity
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // Copy a new array with the new capacity
    elementData = Arrays.copyOf(elementData, newCapacity);
}
// Use the maximum capacity
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}
Copy the code

Execution process:

• Check whether capacity expansion is required.
• If elementData is equal to DEFAULTCAPACITY_EMPTY_ELEMENTDATA, initialize the capacity to DEFAULT_CAPACITY.
• The new capacity is 1.5 times of the oldCapacity (oldCapacity + (oldCapacity >> 1)). If the capacity is smaller than the required capacity, the required capacity prevails.
• Create a new size array and copy the old array into the new array.

Find the union of two sets:

/** * 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. The behavior of this operation is * undefined if the specified collection is modified while the operation * is in progress. (This implies that the behavior of this call is * undefined if the specified collection is this list, And this * list is nonempty.) * Adds all elements from collection C to the current ArrayList * *@param c collection containing elements to be added to this list
 * @return <tt>true</tt> if this list changed as a result of the call
 * @throws NullPointerException if the specified collection is null
 */
public boolean addAll(Collection<? extends E> c) {
    // Convert collection C to an array
    Object[] a = c.toArray();
    int numNew = a.length;
    // Check whether the capacity needs to be expanded
    ensureCapacityInternal(size + numNew);  // Increments modCount
    // Copy all elements in c to the end of the array
    System.arraycopy(a, 0, elementData, size, numNew);
    // The size of the elements in the collection increases the size of c
    size += numNew;
    // Return true if c is not empty, false otherwise
    returnnumNew ! =0;
}
Copy the code

Execution process:

• Copy elements from c into array A;
• Check whether capacity expansion is required.
• Copy elements from array A to the end of elementData;

Removes the element at the specified index position in O(n) time.

/** * Removes the element at the specified position in this list. * Shifts any subsequent elements to the left (SubTRACTS one from their * indices). * Delete the element at the specified index position. The time complexity is O(n). * *@param index the index of the element to be removed
 * @return the element that was removed from the list
 * @throws IndexOutOfBoundsException {@inheritDoc} * /
public E remove(int index) {
    // Check for overbounds
    rangeCheck(index);
    // The number of changes to the underlying array structure of the collection +1
    modCount++;
    // Get the element at index position
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    // If index is not the last digit, move the element after index one digit forward
    if (numMoved > 0)
    	// ** perform the size- index-1 operation **
        System.arraycopy(elementData, index + 1, elementData, index,
                numMoved);
    // Remove the last element to help the GC
    elementData[--size] = null; // clear to let GC do its work
    // Return the old value
    return oldValue;
}
Copy the code

Execution process:

• Check if the index is out of bounds;
• Gets the element at the specified index position;
• If not the last bit is deleted, the other elements move forward one bit;
• Set the last position to null for GC collection;
• Returns the deleted element.

Note: From the source code, ArrayList deletes elements without shrinking. \

* Retains only the elements in this list that are contained in the * specified collection. In other words, removes from this list all * of its elements that are not contained in the specified collection. * *@param c collection containing elements to be retained in this list
 * @return {@code true} if this list changed as a result of the call
 * @throws ClassCastException   if the class of an element of this list
 *                              is incompatible with the specified collection
 *                              (<a href="Collection.html#optional-restrictions">opti
 * @throwsNullPointerException if this list contains a null element and the * specified collection does not permit null elements *  (<a href="Collection.html#optional-restrictions">opti * or if the specified collection is null *@see Collection#contains(Object)
 */
public boolean retainAll(Collection
        c) {
    // Set C cannot be null
    Objects.requireNonNull(c);
    // Invoke the bulk delete method, where complement is passed true to delete elements not included in c
    return batchRemove(c, true);
}
/** * Delete elements in batch. * complement true deletes elements not included in c. * Complement false deletes elements contained in C@param c
 * @param complement
 * @return* /
private boolean batchRemove(Collection<? > c,boolean complement) {
    final Object[] elementData = this.elementData;
    /** * use both Pointers to iterate over the array ** increments the read pointer each time, and increments the write pointer each time it is added to an element */
    int r = 0, w = 0;
    boolean modified = false;
    try {
        // Traverse the array. If c contains the element, put it in the same position as the pointer.
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Normally r is equal to size unless c. containes () throws an exception
        if(r ! = size) {// If c. taines () throws an exception, copy the unread elements to the write pointer
            System.arraycopy(elementData, r,
                    elementData, w,
                    size - r);
            w += size - r;
        }
        if(w ! = size) {// Set the element after the write pointer to null to help GC
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            // The new size is equal to the position of the write pointer.
            size = w;
            modified = true; }}// Returns true with modifications
    return modified;
}
Copy the code

Execution process:

• Iterate over the elementData array;
• If the element is in C, add the element to the W position of the elementData array and move the W position back one bit;
• After traversal, everything before W is common to both, and everything after W is not common to both;
• Set elements after w to null for GC collection;

Directly on the code:

@Test
public void test06(a) {
    // ArrayList Performance deteriorates rapidly due to frequent capacity expansion. What can I do?
    // Examples are as follows:
    ArrayList arrayList = new ArrayList();
    long startTime = System.currentTimeMillis();
    // Add 100W pieces of data to the collection
    for (int i = 0; i < 1000000; i++) {
        arrayList.add(i);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Before optimization, add 1 million data when:" + (endTime - startTime));
    System.out.println("Below --------------- is the solution: ------------------");
    ArrayList arrayList2 = new ArrayList(1000000);
    startTime = System.currentTimeMillis();
    // Add 100W pieces of data to the collection
    for (int i = 0; i < 1000000; i++) {
        arrayList2.add(i);
    }
    endTime = System.currentTimeMillis();
    System.out.println("After optimization, add 1 million data when:" + (endTime - startTime));
}
Copy the code

Output result:

Before optimization, add 100000 data available: 58 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- here's the solution: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- after the optimization, add 100000 data available: 13Copy the code

As you can see, if you define the initial capacity of the ArrayList collection in advance when a large amount of data needs to be added to the collection, you don’t have to spend a lot of time on automatic expansion

Create a new thread task class:

/ * * *@Auther: csp1999
 * @Date: 2020/10/29 / * instructed@Description: Thread task class */
public class CollectionTask implements Runnable {
    // Share the collection
    private List<String> list;
    public CollectionTask(List<String> list){
        this.list = list;
    }
    @Override
    public void run(a) {
        try {
            Thread.sleep(50);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        // Add the current thread name to the collectionlist.add(Thread.currentThread().getName()); }}Copy the code

Next test:

/ * * *@Auther: csp1999
 * @Date: 2020/10/29 / * same@Description: ArrayList thread safety test class */
public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        // Create a collection
        List<String> list = new ArrayList<>();
        // Create a thread task
        CollectionTask collectionTask = new CollectionTask(list);
        // Start 50 threads
        for (int i = 0; i < 50; i++) {
            new Thread(collectionTask).start();
        }
        // Ensure that the child thread completes execution
        Thread.sleep(3000);
        /** * If the ArrayList is thread-safe, then the collection can be traversed to get 50 pieces of data. If the ArrayList is thread-safe, then the collection can be printed to 50 pieces of data. * /
        // iterate over the collection
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --");
        System.out.println("Set length:"+list.size()); }}Copy the code

Test results:

null null null Thread-0 Thread-4 Thread-6 Thread-2 Thread-17 Thread-18 Thread-15 Thread-16 Thread-10 Thread-13 Thread-12  Thread-9 Thread-11 Thread-27 Thread-28 Thread-25 Thread-29 Thread-24 Thread-21 Thread-26 Thread-22 Thread-23 Thread-20 Thread-40 Thread-37 Thread-39 Thread-38 Thread-41 Thread-35 Thread-34 null Thread-31 Thread-33 Thread-32 Thread-49 Thread - 46 Thread - 47 48 Thread Thread - 42-43 Thread - the Thread - 45 Thread - 44 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- set length: 45 Process finished with exit code 0Copy the code

Therefore, ArrayList is not a thread-safe collection! If you need to be thread-safe, we recommend using Vector collections, which are thread-safe but less efficient than arrayLists. What makes Vector thread-safe, compared to ArrayList, is its method of adding elements to the collection:

// The Vector add method uses the synchronized keyword
public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
}
Copy the code

In addition to Vector collections, we can also use the following methods

List<String> list = new ArrayList<>();
List<String> synchronizedList = Collections.synchronizedList(list);
Copy the code

The resulting synchronizedList is also thread-safe!

Note: When can I not lock an ArrayList synchronously?

• First, in the case of a single thread does not need to lock, for efficiency!
• When an ArrayList is used as a local variable, it does not need to be locked because the local variable belongs to a thread. In the example above, ArrayList is used as a member variable. The collection of member variables needs to be shared by all threads.

Question: Given that the set of member variables stores N multiple user names, in a multi-threaded environment, how can iterators be used to read the set of data while still writing data to the set? Create a new thread task class:

/ * * *@Auther: csp1999
 * @Date: 2020/10/29/19:07
 * @Description: Thread task class that uses ArrayList to modify collection data in a multithreaded environment without concurrent modification exception */
public class CollectionThread implements Runnable{
    private static ArrayList<String> list = new ArrayList<>();
    static {
        list.add("Jack");
        list.add("Amy");
        list.add("Lucy");
    }

    @Override
    public void run(a) {
        for (String value : list){
            System.out.println(value);
            // Write data to collection while reading data
            list.add("Coco");// A concurrent modification exception occurs}}}Copy the code

Tests reading data from a shared collection while writing to it in multithreaded conditions:

/ * * *@Auther: csp1999
 * @Date: 2020/10/29 / whom *@Description: Interview question: * Given that the set of member variables stores N multiple user names, in a multithreaded environment, using iterators to read the set of data at the same time, * how to ensure the normal writing of data to the set? * /
public class Test03 {
    public static void main(String[] args) {
        // Create a thread task
        CollectionThread collectionThread = new CollectionThread();

        // Start 10 threads
        for (int i = 0; i < 10; i++) {
            newThread(collectionThread).start(); }}}Copy the code

Test results:

Jack
Jack
Jack
Jack
Jack
Jack
Jack
Jack
Jack
Jack
Exception in thread "Thread-0" Exception in thread "Thread-1" Exception in thread "Thread-4" Exception in thread "Thread-5" Exception in thread "Thread-8" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-9" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-2" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-7" Exception in thread "Thread-6" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-3" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.haust.list.CollectionThread.run(CollectionThread.java:21)
	at java.lang.Thread.run(Thread.java:748)
Copy the code

Concurrent modification exceptions occur. To solve this problem, Java introduces a thread-safe read and write collection (read-write separation collection) : CopyOnWriteArrayList

So the solution is:

.// private static ArrayList<String> list = new ArrayList<>();
    // Replace the original ArrayList with read/write separated collections
    private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
    static {
        list.add("Jack");
        list.add("Amy");
        list.add("Lucy");
    }
    @Override
    public void run(a) {
        for (String value : list){
            System.out.println(value);
            // Write data to collection while reading data
            list.add("Coco");// A concurrent modification exception occurs}}Copy the code

Concurrent modification exception resolved successfully!