Java Collections checkedCollection() Method

The checkedCollection() method in Java provides a way to create a dynamically typesafe view of a collection. This is particularly useful for ensuring that only elements of a specified type are added to the collection, thereby reducing runtime errors and improving type safety.

Table of Contents

1. Introduction
2. checkedCollection() Method Syntax
3. Examples
   • Basic Usage with Checked Collection
   • Using Checked Collection with Custom Classes
4. Real-World Use Case
5. Conclusion

Introduction

The Collections.checkedCollection() method is part of the java.util.Collections class and is used to create a dynamically typesafe view of a specified collection. This means that the collection enforces type checking at runtime, ensuring that only elements of the specified type can be added to the collection.

This method is particularly beneficial when dealing with legacy code or APIs that work with raw types, as it helps prevent accidental insertion of incorrect types, providing a safeguard against ClassCastException at runtime.

checkedCollection() Method Syntax

The syntax for the checkedCollection() method is as follows:

public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)

Parameters:

• c: The collection for which a dynamically typesafe view is to be returned.
• type: The type of element that the collection is permitted to hold.

Returns:

• A dynamically typesafe view of the specified collection.

Throws:

• NullPointerException if the specified collection or type is null.

Examples

Basic Usage with Checked Collection

The following example demonstrates how to use the checkedCollection() method to enforce type safety in a collection.

Example

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

public class CheckedCollectionExample {
    public static void main(String[] args) {
        // Create a raw collection
        Collection rawCollection = new ArrayList();
        
        // Create a checked collection for String type
        Collection<String> stringCollection = Collections.checkedCollection(rawCollection, String.class);

        // Adding elements of correct type
        stringCollection.add("Hello");
        stringCollection.add("World");

        System.out.println("String Collection: " + stringCollection);

        // Attempt to add an element of incorrect type
        try {
            // This line will throw a ClassCastException
            Collection raw = stringCollection;  // Temporarily treat the collection as raw
            raw.add(123);  // Attempt to add an Integer
        } catch (ClassCastException e) {
            System.out.println("Error: Attempted to add an invalid type to the collection");
        }
    }
}

Output:

String Collection: [Hello, World]
Error: Attempted to add an invalid type to the collection

Using Checked Collection with Custom Classes

You can also use the checkedCollection() method with collections containing custom class instances to enforce type safety.

Example

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

class Student {
    String name;

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

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

public class CustomCheckedCollectionExample {
    public static void main(String[] args) {
        Collection<Student> students = new ArrayList<>();

        // Create a checked collection for Student type
        Collection<Student> checkedStudents = Collections.checkedCollection(students, Student.class);

        // Add a valid student object
        checkedStudents.add(new Student("Amit"));
        checkedStudents.add(new Student("Neha"));

        System.out.println("Student Collection: " + checkedStudents);

        // Attempt to add an object of incorrect type
        try {
            Collection raw = checkedStudents;  // Temporarily treat the collection as raw
            raw.add("Invalid Student");  // Attempt to add a String
        } catch (ClassCastException e) {
            System.out.println("Error: Attempted to add an invalid type to the collection");
        }
    }
}

Output:

Student Collection: [Amit, Neha]
Error: Attempted to add an invalid type to the collection

Real-World Use Case

Ensuring Type Safety in Mixed API Environments

In real-world applications, especially when integrating with legacy systems or libraries that use raw types, the checkedCollection() method can enforce type constraints. This helps prevent runtime errors when collections are manipulated across different parts of an application or by different modules.

Example

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

class Employee {
    String name;
    int id;

    Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public String toString() {
        return name + " (ID: " + id + ")";
    }
}

class Student {
   String name;

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

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

public class RealWorldUseCaseExample {
    public static void main(String[] args) {
        // A collection that will be shared across modules
        Collection<Employee> employeeCollection = new ArrayList<>();

        // Create a checked collection for Employee type
        Collection<Employee> checkedEmployeeCollection = Collections.checkedCollection(employeeCollection, Employee.class);

        // Module A adds employees
        checkedEmployeeCollection.add(new Employee("Raj", 101));
        checkedEmployeeCollection.add(new Employee("Simran", 102));

        System.out.println("Employee Collection: " + checkedEmployeeCollection);

        // Module B, potentially written by another developer
        try {
            Collection raw = checkedEmployeeCollection;  // Temporarily treat the collection as raw
            raw.add(new Student("Fake Employee"));  // Attempt to add an incorrect type
        } catch (ClassCastException e) {
            System.out.println("Error: Attempted to add an invalid type to the collection");
        }
    }
}

Output:

Employee Collection: [Raj (ID: 101), Simran (ID: 102)]
Error: Attempted to add an invalid type to the collection

Conclusion

The Collections.checkedCollection() method provides a powerful way to enforce type safety at runtime, helping prevent accidental insertion of incorrect types into collections. This is especially useful when dealing with raw types or integrating with legacy code. By utilizing checkedCollection(), you can enhance the robustness and maintainability of your Java applications.