How To Take Away All Elements From Arraylist Inwards Coffee - Clear Vs Removeall

Many times nosotros desire to reset an ArrayList for the reusing purpose, yesteryear resetting nosotros hateful clearing it or removing all elements. There are ii ways to reset an ArrayList inward Java, yesteryear using clear() method or calling removeAll(). If your ArrayList is pocket-size plenty e.g. contains solely 10 or 100 elements thence you lot tin utilization whatever of these ii methods without worrying likewise much, but, if you lot possess got a huge listing of lots of objects e.g. an ArrayList containing 10M entries, thence selection of clear() vs removeAll() tin brand a huge departure inward functioning of your Java application. Sometimes it's fifty-fifty ameliorate to exercise a novel ArrayList instead of resetting the erstwhile one, peculiarly if resetting takes a long time, but this also has a caveat, you lot need to brand certain that erstwhile ArrayList is eligible for garbage collection, otherwise in that place is a huge gamble of java.lang.OutOfMemoryError: Java Heap Space.

Coming dorsum to clear() vs removeAll() method, you lot should ever utilization clear(), because it gives you lot O(n) performance, spell removeAll(Collection c) is worse, it gives O(n^2) performance, that's why you lot encounter huge departure inward fourth dimension taken yesteryear clearing a large ArrayList yesteryear these ii methods.

Things volition hold upwards obvious, when you lot volition run our instance programme as well as encounter the code of clear() as well as removeAll() method from JDK API. By the way, if you lot are inward doubt, utilization clear() method as well as if non thence ever prefer clear over removeAll inward Java.

Clear() vs RemoveAll(Collection c)

In lodge to compare the functioning of both these methods, it's rattling of import to encounter their code. You tin banking concern tally the root code of the clear() method inward java.util.ArrayList class, for convenience I possess got included it here. This code is from JDK version 1.7.0_40. If you lot desire to larn to a greater extent than most functioning mensuration as well as tuning thence I strongly advise reading Java Performance The Definitive Guide By Scott Oaks. It covers Java seven as well as about bits of Java 8 every bit well.

   /**      * Removes all of the elements from this list.  The listing volition      * hold upwards empty afterward this telephone band returns.      */     public void clear() {         modCount++;         // clear to permit GC exercise its work         for (int i = 0; i < size; i++)             elementData[i] = null;         size = 0;     }

You tin encounter that this method loop over ArrayList as well as assign aught to every chemical constituent to brand them eligible for garbage collection, of class if in that place is no external reference. Similarly, you lot tin banking concern tally the root code of java.util.AbstractCollection bird to hold back at how removeAll(Collection c) method works, hither is snippet:

public boolean removeAll(Collection c) {         boolean modified = false;         Iterator it = iterator();         while (it.hasNext()) {             if (c.contains(it.next())) {                 it.remove();                 modified = true;             }         }         return modified;  }

This implementation iterate over the collection, checking each chemical constituent returned yesteryear the iterator, inward turn, to encounter if it's contained inward the specified collection.  If it's introduce the it is removed from this collection yesteryear using Iterator's take away method. Because of using contains() method, removeAll() functioning goes into the make of O(n^2), which is an absolutely NO, peculiarly if you lot are trying to reset a large ArrayList. Now let's encounter their functioning inward activity to reset an ArrayList of simply 100K entries.

If you lot are interested to a greater extent than inward Java Performance mensuration as well as tuning thence I also advise you lot accept a hold back at Java Performance The Definitive Guide By Scott Oaks, 1 of the best mass on Java profiling.

Removing all elements from ArrayList alongside 100K Objects

I possess got initially tried to run this instance alongside 10M elements but afterward waiting for to a greater extent than than one-half an hr to permit removeAll() finish, I decided to cut down the pose out of objects to 100K, fifty-fifty thence the departure betwixt the fourth dimension taken by clear() vs removeAll() is quite significant. The removeAll(Collection c) are taking 10000 times to a greater extent than fourth dimension than clear to reset.

Actually, the role of clear() as well as removeAll(Collection c) are unlike inward API, clear() method is meant to reset a Collection yesteryear removing all elements, spell removeAll(Collection c) solely removes elements which are introduce inward supplied collection. This method is non designed to remove all elements from a Collection.

So, if your intention is to delete all elements from a Collection, thence use clear(), spell if you lot desire to take away solely about elements, which are introduce inward about other Collection, e.g. listing of unopen orders, thence use removeAll() method .

import java.util.ArrayList;  /**  * Java Program to take away all elements from listing inward Java as well as comparing  * functioning of clearn() as well as removeAll() method.  *  * @author Javin Paul  */ public class ArrayListResetTest {     private static final int SIZE = 100_000;     public static void main(String args[]) {               // Two ArrayList for clear as well as removeAll         ArrayList numbers = new ArrayList(SIZE);         ArrayList integers = new ArrayList(SIZE);                  // Initialize ArrayList alongside 10M integers         for (int i = 0; i < SIZE; i++) {             numbers.add(new Integer(i));             integers.add(new Integer(i));         }               // Empty ArrayList using clear method         long startTime = System.nanoTime();         numbers.clear();         long elapsed = System.nanoTime() - startTime;         System.out.println("Time taken yesteryear clear to empty ArrayList of 1M elements (ns): " + elapsed);                // Reset ArrayList using removeAll method         startTime = System.nanoTime();         integers.removeAll(integers);         long fourth dimension = System.nanoTime() - startTime;         System.out.println("Time taken yesteryear removeAll to reset ArrayList of 1M elements (ns): " + time);     } }  Output: Time taken yesteryear clear to empty ArrayList of 100000 elements (ns): 889619 Time taken yesteryear removeAll to reset ArrayList of 100000 elements (ns): 36633112126

Make certain you lot furnish sufficient retention to run this programme because it's uses ii ArrayList to shop Integers, peculiarly if you lot desire to compare the functioning of clear() as well as removeAll() for List alongside 1M elements. You also need Java seven to run this programme because I am using underscore alongside the numeric literal feature. If you lot don't possess got JDK seven thence simply take away underscores from SIZE constants, those are simply for improving readability.

That's all most how to reset an ArrayList inward Java. We possess got non solely learned ii ways to take away all elements from ArrayList but also learned most the departure betwixt clear vs removeAll method. We possess got seen that removeAll performs poorly when the listing is large as well as that's why you lot should ever prefer clear() over removeAll() inward Java.

By the way, if clearing ArrayList is taking pregnant time, consider using novel ArrayList, every bit Java is pretty fast inward creating objects.

Further Learning
Java In-Depth: Become a Complete Java Engineer
read more)

Java - How to convert ArrayList to Set? (read more)

How to form an ArrayList inward contrary lodge inward Java? (solution)

How to take away duplicate elements from ArrayList inward Java? (solution)

How to clone an ArrayList inward Java? (solution)

How exercise you lot convert a Map to List inward Java? (solution)

Java - Performance comparing of contains() vs binarySearch() (read more)

Java - How to initialize an ArrayList alongside values inward Java? (example)

Java - The ArrayList Guide (tutorial)

The departure betwixt an ArrayList as well as a Vector inward Java? (answer)

How to brand an ArrayList unmodifiable inward Java? (solution)