Sequenced Collections in Java 21

Java has always been a popular programming language for its versatility and robust standard library. With each new version, Java continues to evolve, introducing features that simplify the development process and make code more efficient. Java 21 is no exception, and one of its exciting additions is the concept of "Sequenced Collections."

In this section, we will delve into Sequenced Collections in Java 21, exploring what they are, how they work, and providing complete code examples to help you understand their usage better.

What are Sequenced Collections?

Sequenced Collections are a new type of data structure introduced in Java 21. They combine the benefits of both collections (like lists, sets, and queues) and sequences (like arrays and strings). Sequenced Collections are designed to provide a flexible and efficient way to work with ordered data.

In essence, Sequenced Collections are an ordered collection of elements that allows you to access, insert, and remove elements efficiently. They are designed to offer improved performance compared to traditional lists, especially for scenarios where you frequently need to perform insertions or removals in the middle of the collection.

Key Features of Sequenced Collections

Efficient Insertions and Removals: Sequenced Collections are optimized for inserting and removing elements at any position within the collection, making them suitable for scenarios where you need to maintain an ordered list that frequently changes.

Indexed Access: We can access elements in a Sequenced Collection by their index, just like an array. This allows for efficient random access to elements.
Immutable and Mutable Variants: Java 21 provides both immutable and mutable variants of Sequenced Collections. Immutable variants ensure thread safety and prevent unintended modifications, while mutable variants offer flexibility when you need to change the collection.
Performance Improvements: Sequenced Collections are designed to offer improved performance, especially for large collections, by utilizing advanced data structures under the hood.

Using Sequenced Collections

Creating a Sequenced Collection

To start using Sequenced Collections, you need to import the necessary classes and create an instance of the collection. Here's how you can create a mutable Sequenced List:

SequencedListExample.java

import java.util.ArrayList;
import java.util.List;
public class SequencedListExample {
    public static void main(String[] args) {
        // Create a mutable list (ArrayList)
        List<Integer> myList = new ArrayList<>();
        // Add elements
        myList.add(1);
        myList.add(2);
        myList.add(3);
        // Access elements by index
        int element = myList.get(1); // Returns 2
        System.out.println("Element at index 1: " + element);
        // Remove an element
        myList.remove(0);
        System.out.println("After removing element at index 0: " + myList);
    }
}

Output:

Element at index 1: 2
After removing element at index 0: [2, 3]

Using Immutable Sequenced Collections

Immutable Sequenced Collections ensure that once created, the collection cannot be modified. Here's an example:

ImmutableSequencedListExample.java

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
public class ImmutableSequencedListExample {
    public static void main(String[] args) {
        // Create a mutable list
        List<Integer> mutableList = new ArrayList<>();
        mutableList.add(1);
        mutableList.add(2);
        mutableList.add(3);
        // Create an immutable list from the mutable list
        List<Integer> immutableList = Collections.unmodifiableList(mutableList);
        // Access elements by index
        int element = immutableList.get(0); // Returns 1
        System.out.println("Element at index 0: " + element);
        // Attempting to modify the immutable list will result in an UnsupportedOperationException
        try {
            immutableList.add(4); // Throws UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Attempted to modify the immutable list, which is not allowed.");
        }
    }
}

Output:

Element at index 0: 1
Attempted to modify the immutable list, which is not allowed.

Performance Considerations

The performance of Sequenced Collections is optimized for various scenarios:

Frequent Insertions and Removals: Sequenced Collections offer better performance compared to traditional lists when elements are frequently inserted or removed at arbitrary positions within the collection.
Large Collections: The performance benefits become more pronounced as the size of the collection increases. Sequenced Collections are designed to handle large data sets efficiently.
Random Access: Indexed access to elements in Sequenced Collections is fast, making them suitable for scenarios where we need to retrieve elements by their index.

Conclusion

Sequenced Collections in Java 21 are a powerful addition to the Java standard library, offering an efficient and flexible way to work with ordered data. Whether you need to perform frequent insertions and removals or require indexed access to elements, Sequenced Collections provides an excellent solution. In this article, we've explored the key features of Sequenced Collections and provided complete code examples to help you get started. As Java continues to evolve, it's essential to stay updated with the latest features and best practices to write clean and efficient code.

Next TopicStdin and Stdout in Java

← prev next →