Java Collections.emptySet() Method

The emptySet() method of Java Collections class is used to get the Set that has no elements. These empty Set are immutable in nature.

Syntax

Following is the declaration of emptySet() method:

public static final <t> Set<t> emptySet() 
</t></t>

Parameter

This method does not accept any parameter.

Returns

The emptySet() method returns an empty immutable Set.

Exceptions

Compatibility Version

Java 1.5 and above

Example 1

File Name: CollectionsEmptySetExample1.java

// Importing java.util package to use Collections and Set classes
import java.util.*;
// Declaring a public class named CollectionsEmptySetExample1
public class CollectionsEmptySetExample1 {
    // Main method, entry point of the program
    public static void main(String[] args) {
        // Create an empty Set
        // Using the Collections.emptySet() method to create an empty immutable Set of type String
        Set<string> EmptySet = Collections.<string>emptySet();
        // Print the empty Set
        System.out.println("Empty Set: " + EmptySet);
    }
}
</string></string>

Output:

Empty Set: []

Collections.emptySet() returns an immutable empty set (Collections.EMPTY_SET) of type Set<String>. The set emptySet cannot be modified; any attempt to add, remove, or modify elements will result in an UnsupportedOperationException. Printing emptySet displays an empty set ([]), indicating its immutable and empty state.

Example 2

File Name: CollectionsEmptySetExample2.java

import java.util.*;
public class CollectionsEmptySetExample2 {
    public static void main(String[] args) {
        // Create an empty Set
        // Using Collections.emptySet() to create an empty immutable Set of type String
        Set<string> EmptySet = Collections.emptySet();
        // Print the created empty immutable Set
        System.out.println("Created empty immutable Set: " + EmptySet);
        // Try to add elements
        // This will throw UnsupportedOperationException since EmptySet is immutable
        EmptySet.add("A");  // Attempting to add element "A"
        EmptySet.add("B");  // Attempting to add element "B"
    }
}
</string>

Output:

Created empty immutable Set: []
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.AbstractCollection.add(AbstractCollection.java:267)
	at myPackage.CollectionsEmptySetExample2.main(CollectionsEmptySetExample2.java:10)

Example 3

File Name: CollectionsEmptySetExample2.java

import java.util.*;
public class CollectionsEmptySetExample3 {
    public static void main(String[] args) {
        //Create an empty Set
        // Using Collections.emptySet() to create an empty immutable Set of type Integer
        Set<integer> empSet = Collections.emptySet();
        // Attempt to add elements to the empty Set
        // This line will throw an UnsupportedOperationException because emptySet() returns an immutable set
        empSet.add(1); // Attempt to add 1 to the set
        empSet.add(2); // Attempt to add 2 to the set
        // Print the created empty immutable Set
        // This line will never be reached due to the exception thrown in the previous line
        System.out.println("Created empty immutable Set: " + empSet);
    }
}
</integer>

Output:

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.AbstractCollection.add(AbstractCollection.java:267)
	at myPackage.CollectionsEmptySetExample3.main(CollectionsEmptySetExample3.java:8)

Getting Empty Set of Object Example

In Java, the Collections class provides a convenient way to obtain an immutable empty set of objects using the emptySet() method. This method returns a set that is guaranteed to be empty and immutable, meaning it cannot be modified after it is created.

File Name: EmptyObjectSetExample.java

import java.util.Collections;
import java.util.Set;
public class EmptyObjectSetExample {
    public static void main(String[] args) {
        // Creating an empty set of objects using emptySet()
        Set<Object> emptyObjectSet = Collections.emptySet();
        // The empty set is immutable and cannot be modified
        // Attempting to add an element will throw UnsupportedOperationException
        // emptyObjectSet.add(new Object()); // This will throw UnsupportedOperationException
        // Check the size of the empty set
        System.out.println("Size of empty object set: " + emptyObjectSet.size());
        // Attempt to clear the empty set (which will not throw an exception but has no effect)
        emptyObjectSet.clear();
        // Print a message to show the set is still empty
        System.out.println("After clear operation, size of empty object set: " + emptyObjectSet.size());
        // Print the class name of the empty set
        System.out.println("Class of empty object set: " + emptyObjectSet.getClass().getName());
    }
}

Output:

Size of empty object set: 0
After clear operation, size of empty object set: 0
Class of empty object set: java.util.Collections$EmptySet

Advantages of Collections.emptySet() Method

Immutable Empty Set: Collections.emptySet() returns an immutable (read-only) empty set. It ensures that the set cannot be modified, providing thread safety and preventing accidental changes.
Avoids NullPointerException: It eliminates the need for null checks when returning empty sets. Instead of returning null, which requires additional checks in client code, we can return an empty set using Collections.emptySet().
Convenient and Readable: Using Collections.emptySet() provides a clear and concise way to obtain an empty set instance. It enhances code readability and makes the intent of returning an empty set explicit.
Performance Benefits: Creating and returning a singleton empty set instance (Collections.emptySet()) is more efficient than creating new empty sets every time they are needed. This is because immutable objects can be cached and reused.
Thread Safety: Since the set returned by Collections.emptySet() is immutable, it can be safely accessed and used concurrently in a multi-threaded environment without the need for synchronization.

Disadvantages of Collections.emptySet() Method

Cannot Modify: The set returned by Collections.emptySet() is immutable. While this is generally an advantage for thread safety and clarity, it means that you cannot add, remove, or change elements in the set. Any attempt to modify the set will result in an UnsupportedOperationException.
Limited Use Cases: It can only be used to create an empty set and not for creating a set with initial elements. If you need a set with elements, you would have to use other methods like HashSet or TreeSet.
Potential Confusion: Developers unfamiliar with the method might not immediately recognize its immutability. This could lead to confusion if they attempt to modify the returned set and encounter unexpected UnsupportedOperationExceptions.

Next TopicJava Collections Class

← prev next →