XQA
Back to Java
2026-02-255 min read

ArrayList Methods

Learn ArrayList Methods step by step with clear examples and exercises.

Why This Matters

In this full guide on Java ArrayList methods, we delve deep into understanding various ArrayList methods, their applications, and common pitfalls that may arise while working with them. This tutorial is crucial for programmers aiming to master collection handling, preparing for interviews, or troubleshooting real-world coding issues.

Prerequisites

To fully comprehend the concepts covered in this tutorial, you should have a solid understanding of Java programming fundamentals, including:

  1. Variables and data types
  2. Control structures (if-else, loops)
  3. Object-oriented programming principles
  4. Exception handling
  5. Basic I/O operations
  6. Understanding of interfaces and classes in Java
  7. Familiarity with the java.util package

Core Concept

What is an ArrayList?

In Java, the ArrayList class represents a dynamic array that can expand and contract as needed. Unlike regular arrays, ArrayLists do not have a fixed size, allowing for easy addition or removal of elements. The ArrayList resides in the java.util package.

ArrayList Methods Overview

ArrayList provides numerous methods for executing various operations such as adding, removing, searching, and sorting elements. Here's an overview of some essential ArrayList methods:

  1. add(): Appends an element to the end of the list.
  2. remove(): Eliminates the first occurrence of a specified element from the list.
  3. contains(): Checks if the list contains a specific element.
  4. get(): Retrieves the element at a given index.
  5. set(): Swaps an element at a specified index with a new value.
  6. size(): Returns the number of elements in the list.
  7. isEmpty(): Determines if the list is empty.
  8. clear(): Removes all elements from the list.
  9. indexOf(): Locates the index of the first occurrence of a specified element.
  10. lastIndexOf(): Identifies the index of the last occurrence of a specified element.
  11. subList(): Returns a view of the portion of the list within a specified range.
  12. sort(): Sorts the elements in the ArrayList in ascending order.
  13. reverse(): Reverses the order of the elements in the ArrayList.
  14. containsAll(): Checks if the list contains all the elements from another collection.
  15. retainAll(): Retains only the common elements between the current list and another collection.
  16. removeAll(): Removes all occurrences of the specified elements in the current list.
  17. addAll(): Inserts all the elements from a collection at the end of the current list.
  18. addAll(int index, Collection<? extends E> c): Inserts all the elements from a collection at the specified index in the current list.

Worked Example

Let's create an ArrayList, add some elements, and execute various operations on it:

import java.util.ArrayList;
import java.util.Collections;

public class Main {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<>();

// Adding elements to the ArrayList
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);

System.out.println("Original List: " + numbers);

// Accessing and modifying elements using get(), set(), and add() methods
int thirdElement = numbers.get(2);
System.out.println("Third element: " + thirdElement);
numbers.set(2, 5);
System.out.println("Modified List after set(): " + numbers);
numbers.add(6);
System.out.println("List after adding an element with add(): " + numbers);

// Checking if an element is present using contains() method
boolean isContained = numbers.contains(3);
System.out.println("Is 3 contained in the list? " + isContained);

// Removing elements using remove(), clear(), and retainAll() methods
numbers.remove(1);
System.out.println("List after removing element at index 1: " + numbers);
ArrayList<Integer> numbersToRemove = new ArrayList<>();
numbersToRemove.add(2);
numbersToRemove.add(4);
numbers.retainAll(numbersToRemove);
System.out.println("List after retainAll(): " + numbers);
numbers.clear();
System.out.println("List after clearing all elements: " + numbers);

// Sorting and reversing the list using sort() and reverse() methods
ArrayList<Integer> sortedNumbers = new ArrayList<>(numbers);
Collections.sort(sortedNumbers);
System.out.println("Sorted List: " + sortedNumbers);
Collections.reverse(sortedNumbers);
System.out.println("Reversed List: " + sortedNumbers);
}
}

Common Mistakes

1. Forgetting to import the ArrayList class

Remember to include the following line at the beginning of your Java file:

import java.util.ArrayList;

2. Using index out of bounds exception

Ensure that the index used when accessing or modifying elements is within the valid range (0 to size() - 1).

3. Not handling null values correctly

If you're working with ArrayLists containing objects, be cautious not to add a null value as it may cause issues during runtime.

4. Misusing the remove() method

The remove() method removes the first occurrence of the specified element by its value. If you want to remove an element at a specific index, use the remove(int index) method instead.

Practice Questions

  1. Write a program that creates an ArrayList of strings and sorts it in alphabetical order using the sort() method.
  2. Given an ArrayList of integers, write a function that finds the second highest number in the list.
  3. Implement a program that removes all duplicates from an ArrayList of strings.
  4. Write a program that merges two ArrayLists of integers into one sorted ArrayList using the addAll() method.
  5. Given an ArrayList of words, write a function that checks if any palindromes exist in the list.
  6. Implement a program that finds the kth smallest element in an ArrayList of numbers using quickselect algorithm.
  7. Write a program that reverses the order of elements in an ArrayList using recursion.
  8. Given two ArrayLists of integers, write a function that returns true if they have the same number of occurrences for each integer value (frequency distribution is equal).
  9. Implement a program that finds the longest common subsequence between two strings represented as ArrayLists of characters.

FAQ

Q: Can I add null values to an ArrayList?

A: Yes, you can add null values to an ArrayList, but it's generally recommended to avoid doing so as it may lead to unexpected behavior in your code.

Q: What happens when I try to add more elements to an ArrayList that has reached its maximum capacity?

A: When the ArrayList reaches its maximum capacity and you attempt to add more elements, a java.lang.ArrayIndexOutOfBoundsException will be thrown. To avoid this, you can either increase the ArrayList's capacity using the ensureCapacity() method or create a new ArrayList with a larger size.

Q: What is the difference between an ArrayList and a LinkedList?

A: While both ArrayList and LinkedList are used to store collections of elements in Java, there are differences in their implementation and performance characteristics. ArrayList uses an array under the hood, providing faster access to elements by index but slower insertion and deletion operations at the beginning of the list. On the other hand, LinkedList uses nodes connected by links, offering faster insertion and deletion operations at the beginning or end of the list but slower access to elements by index.

ArrayList Methods | Java | XQA Learn