ArrayList class in Java

The Java ArrayList class provided methods are implemented in the below given examples. Let's go through the examples one by one and understand the uses for each method.

Constructor Name and Descriptions
ArrayList() Constructs an empty list with an initial capacity of ten.
ArrayList(Collection<? extends E> c) Constructs a list containing the elements of the specified collection in the order they are returned by the collection's iterator.
ArrayList(int initialCapacity) Constructs an empty list with the specified initial capacity.

Method Name	Description
add(Object o)	This method is used to append a specific element to the end of a list.
add(int index, Object element)	This method is used to insert a specific element at a specific position index in a list.
addAll(Collection C)	This method is used to append all the elements from a specific collection to the end of the mentioned list in such an order that the values are returned by the specified collection’s iterator.
addAll(int index, Collection C)	Used to insert all of the elements starting at the specified position from a specific collection into the mentioned list.
clear()	This method is used to remove all the elements from any list.
clone()	This method is used to return a shallow copy of an ArrayList.
contains(Object o)	Returns true if this list contains the specified element.
ensureCapacity(int minCapacity)	Increases the capacity of this ArrayList instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
forEach(Consumer<? super E> action)	Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.
get(int index)	Returns the element at the specified position in this list.
indexOf(Object O)	The index for the first occurrence of a specific element is either returned or -1 in case the element is not in the list.
isEmpty()	Returns true if this list contains no elements.
lastIndexOf(Object O)	The index of the last occurrence of a specific element is either returned or -1 in case the element is not in the list.
listIterator()	It returns a list iterator over the elements in this list (in proper sequence).
listIterator(int index)	Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
remove(int index)	Removes the element at the specified position in this list.
remove(Object o)	Removes the first occurrence of the specified element from this list, if it is present.
removeAll(Collection c)	Removes from this list all of its elements that are contained in the specified collection.
removeIf(Predicate filter)	Removes all of the elements of this collection that satisfy the given predicate.
removeRange(int fromIndex, int toIndex)	Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
retainAll(Collection<?> c)	Retains only the elements in this list that are contained in the specified collection.
set(int index, E element)	Replaces the element at the specified position in this list with the specified element.
size()	Returns the number of elements in this list.
spliterator()	Creates a late-binding and fail-fast Spliterator over the elements in this list.
subList(int fromIndex, int toIndex)	Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.
toArray()	This method is used to return an array containing all of the elements in the list in the correct order.
toArray(Object[] O)	It is also used to return an array containing all of the elements in this list in the correct order, the same as the previous method.
trimToSize()	This method is used to trim the capacity of the instance of the ArrayList to the list’s current size.

  import java.util.ArrayList;
  import java.util.Arrays;
  public class ArrayListAddElements {
    public static void main(String[] args) {
      // Creating ArrayList
      ArrayList<Integer> list = new ArrayList<>();
      
      // Adding elements in the list
      list.add(100);
      list.add(200);
      list.add(400);
      list.add(500);
      System.out.println("ArrayList elements: " + list);
      
      // Adding element at the required index position in the ArrayList
      list.add(2, 300);
      System.out.println("ArrayList elements after adding elements at index 2 : " + list);
      
      // Creating another ArrayList
      ArrayList<Integer> childList = new ArrayList<>();
      childList.add(600);
      childList.add(700);
      
      // Appends all of the elements in the specified collection to end of the ArrayList
      list.addAll(childList);
      
      // Appends all of the elements in the specified collection into the ArrayList
      list.addAll(3, childList);
      
      // Printing the value
      System.out.println("ArrayList elements after adding another ArrayList : " + list);
      
      // Adding the elements through array
      list.addAll(Arrays.asList(1000, 2000, 3000, 4000));
      
      // ArrayList Declaration, Instantiation and Initialization in a single statement
      ArrayList<Character> arrayList = new ArrayList<>(Arrays.asList('A', 'B', 'C', 'D'));
      
      // Printing list values
      System.out.println("ArrayList elements : " + arrayList);
    }
  }

ArrayList elements: [100, 200, 400, 500]
ArrayList elements after adding elements at index 2 : [100, 200, 300, 400, 500]
ArrayList elements after adding another ArrayList : [100, 200, 300, 600, 700, 400, 500, 600, 700]
ArrayList elements : [A, B, C, D]

  import java.util.ArrayList;
  public class ArrayListGetMethodExample {
    public static void main(String[] args) {
      ArrayList<String> list = new ArrayList<>();
      
      list.add("India");
      list.add("USA");
      list.add("Canada");
      list.add("South Africa");
      list.add("Sri Lanka");
      
      // Returns the element at the specified position in the ArrayList.
      System.out.println("ArrayList value : " + list.get(3));
    }
  }

  import java.util.ArrayList;
  public class ArrayListUpdateElements {
    public static void main(String[] args) {
      
      // Creating ArrayList
      ArrayList<Integer> list = new ArrayList<>();
        
      // Adding elements in the list
      list.add(100);
      list.add(200);
      list.add(400);
      list.add(400);
      System.out.println("ArrayList elements: " + list);
      // Replaces the element at the specified position in this list.
      list.set(2, 300);
      System.out.println("ArrayList after update the element: " + list);
    }
  }

ArrayList elements: [100, 200, 400, 400]
ArrayList after update the element: [100, 200, 300, 400]

  import java.util.ArrayList;
  public class ArrayListRemoveElements {
    public static void main(String[] args) {
      // Creating ArrayList 
      ArrayList<String> list = new ArrayList<String>();
        
      list.add("Java");
      list.add("Hibernate");
      list.add("Kafka");
      list.add("MongoDB");
      list.add("Jenkins");
      list.add("MySQL");
      list.add("JSF");
      list.add("Spring");
      list.add("Microservices");
      
      System.out.println("ArrayList elements: " + list);
      
      // Removes the element at the specified index in the ArrayList.
      list.remove(3);
      System.out.println("Array List after calling remove(int index) method: " + list);
      
      // Removes the first occurrence of the specified element from the ArrayList
      list.remove("JSF");
      System.out.println("Array List after calling remove(Object o) method: " + list);
      
      // Creating another ArrayList
      ArrayList<String> childList = new ArrayList<>();
        
      childList.add("Kafka");
      childList.add("MySQL");
      childList.add("Microservices");
      
      // Removes from this list all of its elements that are contained in the
      // specified collection.
      list.removeAll(childList);
      System.out.println("Array List after calling removeAll(Collection c) method: " + list);
      
      // Removes all of the elements of this collection that satisfy the given predicate.
      list.removeIf(n -> (n.charAt(0) == 'J')); // Removing names start with J
      
      // Now finally printing the list
      System.out.println("After all remove() methods, Final ArrayList elements: ");
      for (String course : list) {
        System.out.println(course);
      }
    }
  }

ArrayList elements: [Java, Hibernate, Kafka, MongoDB, Jenkins, MySQL, JSF, Spring, Microservices]
Array List after calling remove(int index) method: [Java, Hibernate, Kafka, Jenkins, MySQL, JSF, Spring, Microservices]
Array List after calling remove(Object o) method: [Java, Hibernate, Kafka, Jenkins, MySQL, Spring, Microservices]
Array List after calling removeAll(Collection c) method: [Java, Hibernate, Jenkins, Spring]
After all remove() methods, Final ArrayList elements:
Hibernate
Spring

  import java.util.ArrayList;
  import java.util.Arrays;
  public class ArrayListUtilityMethods {
    public static void main(String[] args) {
      
      ArrayList<String> list = new ArrayList<>(
      Arrays.asList("India", "USA", "Canada", "South Africa", "Sri Lanka"));
      
      // Returns 'true' if list contains the specified element otherwise 'false'
      System.out.println(list.contains("Canada")); 	// Output : true
      System.out.println(list.contains("Nepal")); 	// Output : false
      
      ArrayList<String> childList = new ArrayList<>(Arrays.asList(
                                            "USA", "Germany", "England", "Japan"));
        
      // Returns 'true' if the list contains all of the elements childList
      System.out.println(list.containsAll(childList)); // Output : false
      
      // ArrayList size before calling clear() method
      System.out.println("ArrayList Size Before : " + list.size());
      
      // Removes all of the elements from this list.
      list.clear();
      
      // ArrayList size after calling clear() method
      System.out.println("ArrayList Size After : " + list.size());
    }
  }

ArrayList	Array
The size of an ArrayList is dynamic and can be increased or decreased as needed.	Array size is fixed. Once declared, its size can’t be changed.
ArrayList can only have one dimension.	An array can be single or multidimensional.
ArrayList can only hold reference types (objects), not primitives.	An array can hold both primitives and reference types (objects) in Java.
ArrayList supports generics.	Array does not support generics.
When compared to an array, an ArrayList performs worse and consumes more memory.	Array provides better performance and uses less memory.
ArralyList provides various ways for iteration, like loops, Iterator, and ListIterator class.	We can iterate through an array using loops only.
ArrayList elements are not stored at contiguous memory locations.	Array elements are stored at contiguous memory locations.
We can add elements to the ArrayList using the add() method.	Using the assignment operator, we can add elements to the array.

Comparison Parameters	ArrayList Vs Vector

Synchronization	ArrayList is not synchronized (not thread-safe), which means multiple threads can access an ArrayList object at the same time. Vector, on the other hand, is synchronised (thread-safe), so only one thread can access the vector object at a time.

Performance	ArrayList is faster since it is non-synchronized, whereas Vector is by default synchronized so its operations give slower performance.

Data Growth	ArrayList and Vector both grow and shrink dynamically to maintain optimal use of storage. ArrayList increases by 50% of the current array size if the number of elements exceeds its capacity, whereas Vector increases by 100%, essentially doubling the current array size.

Traversal	ArrayList can only use an iterator to traverse its elements, whereas Vector can use both an enumeration and an iterator to traverse its elements.

Legacy Class	ArrayList was introduced in the JDK 1.2 version, and ArrayList is not a legacy class, whereas Vector is a legacy class. It was introduced in the JDK 1.0 version.

ArrayList	LinkedList
ArrayList internally uses a dynamic array to store the elements.	LinkedList internally uses a doubly linked list to store the elements.
ArrayList implements the List interface. Therefore, this acts as a list.	LinkedList implements both the List interface and the Deque interface. Therefore, it can act as both a list and a deque.
ArrayList is slow because array manipulation is slower.	LinkedList is faster than node-based as there is not much bit shifting required.
ArrayList is best for storing and accessing elements from the list.	For manipulating the elements, LinkedList is the best choice.
ArrayList allocates contiguous memory locations.	LinkedList does not allocate contiguous memory locations.
The default capacity of an ArrayList is 10.	LinkedList has no default capacity. An empty list is created when a LinkedList is initialized.

ArrayList Class in Java

👉 Java ArrayList has important features:

👉 Java ArrayList Class Hierarchy

👉 Java ArrayList Class Declaration

👉 Example : A sample Java program of ArrayList

👉 Java ArrayList Constructors

👉 Java ArrayList Methods

ArrayList Class Methods Examples

ArrayList - Interview Questions and Answers

Currently No Video available