Introduction

In Java, working with collections is a common practice in software development. Collections allow you to store, manipulate, and retrieve data in various ways. However, sometimes it is necessary to ensure that the contents of a collection cannot be modified after creation. This is known as creating a read-only collection or an immutable collection.

This article will explore how to make a read-only collection in Java using different approaches and discuss some practical scenarios where this might be useful. We’ll cover how to use the Java Collections Framework, the Java 9+ List.of() method, and techniques to prevent modification of collections.

Why Use Read-Only Collections?

Read-only collections are important in scenarios where data integrity is a priority. By ensuring that a collection cannot be modified, we can prevent bugs that may arise from accidental or unauthorized changes. Additionally, making a collection read-only allows for better thread-safety and can improve performance in concurrent environments.

Approach 1: Using Collections.unmodifiableXXX Methods

One of the simplest ways to make a collection read-only in Java is by using the Collections.unmodifiableList(), Collections.unmodifiableSet(), and Collections.unmodifiableMap() methods. These methods return a view of the specified collection that does not support modification operations such as add(), remove(), and clear().

Example: Making a List Read-Only

import java.util.*;

public class ReadOnlyExample {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");
        
        List readOnlyList = Collections.unmodifiableList(list);
        
        // Attempting to modify the list will throw an UnsupportedOperationException
        try {
            readOnlyList.add("Ruby"); // This will throw an exception
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify the list: " + e.getMessage());
        }
        
        System.out.println("Read-Only List: " + readOnlyList);
    }
}
            

The above example demonstrates how to make a list read-only by wrapping it with Collections.unmodifiableList(). Any attempt to modify the list through the readOnlyList will result in an UnsupportedOperationException.

How It Works

In the example above, we first create a normal ArrayList and populate it with some elements. Then, we create an unmodifiable view of the list using Collections.unmodifiableList(). The underlying list can still be modified directly (via the original reference), but the read-only view will prevent any changes to it through the unmodifiable reference.

Approach 2: Using Java 9+ Immutable Collections

With the introduction of Java 9, we got a much easier and more elegant way to create read-only collections. Java 9 introduced several methods for creating immutable collections, including List.of(), Set.of(), and Map.of().

Example: Making an Immutable List

import java.util.*;

public class ImmutableListExample {
    public static void main(String[] args) {
        List immutableList = List.of("Java", "Python", "C++");
        
        // Attempting to modify the list will throw an UnsupportedOperationException
        try {
            immutableList.add("Ruby"); // This will throw an exception
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify the list: " + e.getMessage());
        }
        
        System.out.println("Immutable List: " + immutableList);
    }
}
            

In this example, we use List.of() to create an immutable list. This list cannot be modified (i.e., you cannot add, remove, or replace elements), and any such attempt will throw an UnsupportedOperationException.

How It Works

Java 9’s List.of() method returns an immutable list that disallows any structural modifications. It is important to note that this method does not allow null elements, and the collection is fixed in size once created. This approach provides a simpler and more concise way to create read-only collections compared to the older Collections.unmodifiableList() method.

Approach 3: Using Java’s Immutable Collections from Guava

Guava, a popular open-source library developed by Google, provides many utilities for working with collections. One such utility is the ImmutableList class, which creates a truly immutable list that cannot be modified in any way after creation.

Example: Using Guava’s ImmutableList

import com.google.common.collect.ImmutableList;

public class GuavaImmutableListExample {
    public static void main(String[] args) {
        ImmutableList guavaImmutableList = ImmutableList.of("Java", "Python", "C++");
        
        // The list is immutable, so no modification is possible
        try {
            guavaImmutableList.add("Ruby"); // This will throw an UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify the list: " + e.getMessage());
        }
        
        System.out.println("Guava Immutable List: " + guavaImmutableList);
    }
}
            

In this example, we create an immutable list using ImmutableList.of() from the Guava library. This approach ensures that the collection cannot be changed in any way, even if the underlying list reference is accessible elsewhere.

How It Works

Guava’s ImmutableList is designed for high performance and guarantees that no changes can be made after the list is created. Unlike Java’s built-in immutable collections, Guava’s collections are strongly optimized for performance and are often used in production systems where immutability is a core requirement.

Best Practices for Read-Only Collections

• Use Java 9+ Immutable Collections: If you are working with Java 9 or newer, prefer using List.of(), Set.of(), or Map.of() to create immutable collections. These methods are simple and concise.
• Use Collections.unmodifiableXXX Methods: If you are working with Java 8 or older, use Collections.unmodifiableList(), Collections.unmodifiableSet(), etc., to create read-only views of your collections.
• Leverage Immutable Libraries (like Guava): For projects that require extra performance and immutability guarantees, consider using Guava’s ImmutableList or similar classes.

Conclusion

Creating read-only or immutable collections in Java is a powerful technique for ensuring data integrity and preventing unintended modifications. Whether you are using built-in Java 9+ methods or libraries like Guava, there are various ways to achieve this. By making collections immutable, you can improve the safety, reliability, and performance of your applications.

Now that you know how to create read-only collections in Java, you can choose the approach that best suits your needs based on the version of Java you are using and the requirements of your project.