Efficiently Retrieve the Last Element of an ArrayList in Java

Introduction

Retrieving the last element from an ArrayList is a common task in Java programming. This operation can be performed using various methods, each with its own benefits and considerations. Understanding these approaches helps ensure efficient and error-free code. In this tutorial, we’ll explore different techniques to get the last value of an ArrayList, focusing on both standard Java methods and third-party libraries.

Using Standard Java

Basic Method (Pre-Java 21)

The most straightforward way to access the last element of a non-empty ArrayList in Java is by using the get() method combined with size() - 1. This approach works efficiently for any list that implements the List interface, including ArrayList.

Here’s how you can implement this:

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("First");
        arrayList.add("Second");
        arrayList.add("Third");

        if (!arrayList.isEmpty()) {
            String lastElement = arrayList.get(arrayList.size() - 1);
            System.out.println("Last Element: " + lastElement);
        } else {
            System.out.println("The list is empty.");
        }
    }
}

Considerations:

This method throws an IndexOutOfBoundsException if the list is empty, so it’s essential to check if the list isn’t empty before accessing its size.

Using Java 21 Feature

From Java 21 onwards, a more elegant solution exists with the introduction of the getLast() method in the SequencedCollection interface. This method simplifies retrieving the last element by throwing a NoSuchElementException when the collection is empty:

import java.util.ArrayList;

public class NewArrayListExample {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("First");
        arrayList.add("Second");
        arrayList.add("Third");

        try {
            String lastElement = arrayList.getLast();
            System.out.println("Last Element: " + lastElement);
        } catch (NoSuchElementException e) {
            System.out.println("The list is empty.");
        }
    }
}

Benefits:

Simplifies the code by handling checks internally and using a more specific exception (NoSuchElementException).

Using Third-Party Libraries

Google Guava Library

For those working with older versions of Java (before 21) or preferring an alternative approach, the Google Guava library offers utility methods such as Iterables.getLast(). This method provides flexibility by allowing you to specify a default value if the list is empty:

import com.google.common.collect.Iterables;
import java.util.ArrayList;

public class GuavaExample {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("First");
        arrayList.add("Second");

        // Using Iterables.getLast()
        String lastElement = Iterables.getLast(arrayList, "Default Value");
        System.out.println("Last Element: " + lastElement);
    }
}

Advantages:

Allows specification of a default value to avoid exceptions when the list is empty.
Provides a cleaner API compared to manual index handling.

Custom Utility Methods

For those who prefer not to depend on third-party libraries, creating a utility class can encapsulate common operations like retrieving the first or last elements from a list:

import java.util.List;

public final class ListUtils {

    private ListUtils() {
        // Private constructor to prevent instantiation
    }

    public static <T> T getLast(List<T> list) {
        return list != null && !list.isEmpty() ? list.get(list.size() - 1) : null;
    }
    
    public static <T> T getLastOrDefault(List<T> list, T defaultValue) {
        return isEmpty(list) ? defaultValue : list.get(list.size() - 1);
    }

    private static <T> boolean isEmpty(List<T> list) {
        return list == null || list.isEmpty();
    }
}

// Usage
import java.util.ArrayList;

public class UtilityExample {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("First");
        arrayList.add("Second");

        String lastElement = ListUtils.getLast(arrayList);
        System.out.println("Last Element: " + (lastElement != null ? lastElement : "No element found"));

        // Using getLastOrDefault
        String defaultValue = "Default Value";
        String safeLastElement = ListUtils.getLastOrDefault(arrayList, defaultValue);
        System.out.println("Safe Last Element: " + safeLastElement);
    }
}