Java Collections emptySortedSet() Method

The emptySortedSet() method in Java returns an immutable SortedSet that contains no elements. It is part of the java.util.Collections class and provides a convenient way to obtain an empty sorted set, which can be useful in scenarios where a method requires a sorted set but no elements are available.

Table of Contents

1. Introduction
2. emptySortedSet() Method Syntax
3. Examples
   • Basic Usage of emptySortedSet()
   • Using emptySortedSet() in a Custom Method
4. Real-World Use Case
5. Conclusion

Introduction

The Collections.emptySortedSet() method returns a statically typed, immutable sorted set that contains no elements. This method is useful when you need to return a sorted set from a method, but there are no elements to provide. By using emptySortedSet(), you can avoid returning null and prevent potential NullPointerException errors in your code.

A SortedSet is an interface that extends the Set interface and provides additional methods for dealing with ordered elements. The set returned by emptySortedSet() is immutable, meaning it cannot be modified. Any attempts to add, remove, or change elements will result in an UnsupportedOperationException.

emptySortedSet() Method Syntax

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

public static <E> SortedSet<E> emptySortedSet()

Parameters:

• This method does not take any parameters.

Returns:

• An immutable empty SortedSet.

Examples

Basic Usage of emptySortedSet()

The following example demonstrates how to use the emptySortedSet() method to obtain an immutable empty sorted set.

Example

import java.util.Collections;
import java.util.SortedSet;

public class EmptySortedSetExample {
    public static void main(String[] args) {
        // Obtain an empty sorted set
        SortedSet<String> emptySortedSet = Collections.emptySortedSet();

        // Check if the sorted set is empty
        System.out.println("Is the sorted set empty? " + emptySortedSet.isEmpty());

        // Attempt to iterate over the sorted set
        System.out.println("Sorted set size: " + emptySortedSet.size());

        // Attempt to modify the sorted set (will throw UnsupportedOperationException)
        try {
            emptySortedSet.add("Element");
        } catch (UnsupportedOperationException e) {
            System.out.println("Error: Cannot add elements to an immutable sorted set");
        }
    }
}

Output:

Is the sorted set empty? true
Sorted set size: 0
Error: Cannot add elements to an immutable sorted set

Using emptySortedSet() in a Custom Method

You can use the emptySortedSet() method to return an empty sorted set from a custom method when there are no elements to provide.

Example

import java.util.Collections;
import java.util.SortedSet;
import java.util.TreeSet;

public class CustomMethodExample {
    public static void main(String[] args) {
        // Get a non-empty sorted set of numbers
        SortedSet<Integer> numbers = getNumbers(true);
        System.out.println("Numbers (non-empty): " + numbers);

        // Get an empty sorted set of numbers
        numbers = getNumbers(false);
        System.out.println("Numbers (empty): " + numbers);
    }

    // Method to return a sorted set of numbers based on a condition
    public static SortedSet<Integer> getNumbers(boolean hasNumbers) {
        if (hasNumbers) {
            SortedSet<Integer> numbers = new TreeSet<>();
            numbers.add(1);
            numbers.add(2);
            numbers.add(3);
            return numbers;
        } else {
            return Collections.emptySortedSet();
        }
    }
}

Output:

Numbers (non-empty): [1, 2, 3]
Numbers (empty): []

Explanation:

1. Non-Empty Sorted Set: When hasNumbers is true, the getNumbers() method returns a sorted set containing numbers using a TreeSet.

2. Empty Sorted Set: When hasNumbers is false, the method returns an empty sorted set using emptySortedSet(), demonstrating its utility in cases where no elements are needed.

Real-World Use Case

Providing Default Empty Sorted Sets in APIs

In API development, it is common to have methods that return sorted sets. Using emptySortedSet() can provide a safe default when there are no elements to return, avoiding null values and potential errors.

Example

Imagine a scenario where you have an API method that retrieves a sorted set of product IDs based on specific criteria. If no products meet the criteria, you can return an empty sorted set instead of null.

import java.util.Collections;
import java.util.SortedSet;
import java.util.TreeSet;

class Product {
    String name;
    int id;

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

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

public class ProductService {
    // Method to get a sorted set of product IDs based on a condition
    public SortedSet<Integer> getProductIds(boolean hasProducts) {
        if (hasProducts) {
            SortedSet<Integer> productIds = new TreeSet<>();
            productIds.add(101);
            productIds.add(102);
            return productIds;
        } else {
            return Collections.emptySortedSet();
        }
    }

    public static void main(String[] args) {
        ProductService productService = new ProductService();

        // Retrieve a non-empty sorted set of product IDs
        SortedSet<Integer> productIds = productService.getProductIds(true);
        System.out.println("Product IDs (non-empty): " + productIds);

        // Retrieve an empty sorted set of product IDs
        productIds = productService.getProductIds(false);
        System.out.println("Product IDs (empty): " + productIds);
    }
}

Output:

Product IDs (non-empty): [101, 102]
Product IDs (empty): []

Explanation:

1. Non-Empty Sorted Set: When hasProducts is true, the getProductIds() method returns a sorted set of product IDs, demonstrating how sets can be populated with entries when available.

2. Empty Sorted Set: When hasProducts is false, the getProductIds() method returns an empty sorted set using emptySortedSet(), ensuring that the method handles cases with no products correctly.

Conclusion

The Collections.emptySortedSet() method is a useful utility for obtaining an immutable empty sorted set in Java. By providing a typesafe, empty sorted set, it helps prevent NullPointerException errors and ensures that your code handles cases where no elements are present gracefully. This method is particularly valuable when implementing APIs or methods that require sorted sets but may not always have elements to return, enhancing the robustness and maintainability of your Java applications.