Java ArrayList removeLast() Method (introduced in Java 21)

The ArrayList.removeLast() method, introduced in Java 21, is used to remove the last element from an ArrayList. This guide will cover the method’s usage, explain how it works, and provide examples to demonstrate its functionality. Additionally, we will cover a real-world use case to illustrate its application.

Table of Contents

1. Introduction
2. removeLast Method Syntax
3. How It Works
4. Examples
   • Removing the Last Element
   • Handling Empty ArrayList
5. Real-World Use Case
6. Conclusion

Introduction

The ArrayList.removeLast() method is part of the ArrayList class in Java 21. It allows you to remove the last element of the list directly, simplifying the process of removing the last element without needing to handle the index manually.

removeLast Method Syntax

The syntax for the removeLast method is as follows:

public E removeLast()

• The method returns the element that was removed from the ArrayList.

How It Works

When you use the removeLast() method, the ArrayList removes the element at the last position (index size() - 1). If the list is empty, the method throws a NoSuchElementException.

Examples

Removing the Last Element

The removeLast method can be used to remove the last element of the ArrayList.

Example

import java.util.ArrayList;
import java.util.List;

public class RemoveLastExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        // Remove the last element
        String lastElement = ((ArrayList<String>) list).removeLast();

        System.out.println("Removed element: " + lastElement);
        System.out.println("List after removal: " + list);
    }
}

Output:

Removed element: Orange
List after removal: [Apple, Banana]

Handling Empty ArrayList

Attempting to remove the last element from an empty ArrayList will throw a NoSuchElementException. It’s important to handle this case properly.

Example

import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;

public class RemoveLastWithExceptionHandling {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        // Remove the last element with exception handling
        try {
            String lastElement = ((ArrayList<String>) list).removeLast();
            System.out.println("Removed element: " + lastElement);
        } catch (NoSuchElementException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Output:

Error: No elements found in the list

Real-World Use Case

Processing the Last Task in a Queue

In a task management system, you might want to process and remove the last task in a queue. The removeLast() method can be used to quickly access and remove the last task.

Example

import java.util.ArrayList;
import java.util.List;

class Task {
    String name;

    Task(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

public class TaskQueue {
    public static void main(String[] args) {
        List<Task> taskQueue = new ArrayList<>();
        taskQueue.add(new Task("Write report"));
        taskQueue.add(new Task("Prepare presentation"));
        taskQueue.add(new Task("Fix critical bug"));

        // Process and remove the last task
        Task lastTask = ((ArrayList<Task>) taskQueue).removeLast();

        System.out.println("Processed task: " + lastTask);
        System.out.println("Remaining tasks: " + taskQueue);
    }
}

Output:

Processed task: Fix critical bug
Remaining tasks: [Write report, Prepare presentation]

Conclusion

The ArrayList.removeLast() method in Java 21 provides a convenient way to remove the last element from an ArrayList. By understanding how to use this method, you can efficiently manage the contents of your lists in Java applications. It’s important to handle potential NoSuchElementException by ensuring that the list is not empty before attempting to remove the last element. This method is particularly useful in real-world applications such as processing tasks in a queue or managing the last item in a collection.