Java Collections emptyList() Method

The emptyList() method of Java Collections class is used to get a List that has no elements. These empty list are immutable in nature.

The Collections.emptyList() method in Java, part of the java.util.Collections class, returns an immutable empty List. This means that the list cannot be modified after it is created, ensuring that it remains empty throughout its lifecycle.

The primary use case for emptyList() is when you need to return a list from a method or assign an empty list to a variable, but you want to ensure that the list cannot be modified accidentally. By using an immutable empty list, you can guarantee that the list will remain empty and unchanged.

Syntax

Following is the declaration of emptyList() method:

public static final <t> List<t> emptyList()
</t></t>

Parameter

The method does not accept any parameter.

Returns

The emptyList() method returns an empty immutable list.

Exceptions

Compatibility Version

Java 1.5 and above

Example 1

CollectionsEmptyListExample1.java

import java.util.*;
public class CollectionsEmptyListExample1 {
	public static void main(String[] args) {		
	     //Create an empty List    
	     List<string> EmptyList = Collections.<string>emptyList();
	     System.out.println("Empty list: "+EmptyList);
	     }	  
}
</string></string>

Test it Now

Output:

Empty list: []

One important feature of emptyList() is that it returns the same instance of an empty list every time it is called. This means that if you call emptyList() multiple times, you will always get the same list object. The behavior can be useful for saving memory, as you only need one instance of an empty list in your program.

Since the returned list is immutable, attempting to modify it using methods like add() or remove() will result in an UnsupportedOperationException. This ensures that the empty list remains empty and cannot be changed, further guaranteeing its immutability.

Example 2

CollectionsEmptyListExample2.java

import java.util.*;
public class CollectionsEmptyListExample2 {
	public static void main(String[] args) {		
		//Create an empty List  
	      List<string> emptylist = Collections.emptyList();
	      System.out.println("Created empty immutable list: "+emptylist);
	      //Try to add elements
	      emptylist.add("A");
	      emptylist.add("B");
	      }	  
}
</string>

Test it Now

Output:

Created empty immutable list: []
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.AbstractList.add(AbstractList.java:153)
	at java.base/java.util.AbstractList.add(AbstractList.java:111)
	at myPackage.CollectionsEmptyListExample1.main(CollectionsEmptyListExample1.java:9)

Example 3

CollectionsEmptyListExample3.java

import java.util.*;
public class CollectionsEmptyListExample3 {
	public static void main(String[] args) {		
		//Create an empty List    
	      List<integer> empList = Collections.emptyList();
	      empList.add(1);
	      empList.add(2);    
	      System.out.println("Created empty immutable List: "+empList);	     
	      }	  
}
</integer>

Test it Now

Output:

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.AbstractList.add(AbstractList.java:153)
	at java.base/java.util.AbstractList.add(AbstractList.java:111)
	at myPackage.CollectionsEmptyListExample3.main(CollectionsEmptyListExample3.java:8)

Let's understand about Java Collections emptyList() Method in detail with the help of few Java example programs.

Example 1:

Filename: EmptyListExample.java

// Java program for demonstrating the features and functionalities of Java Collections emptyList() method. 
import java.util.Collections;
import java.util.List;
public class EmptyListExample {
    public static void main(String[] args) {
        // Create an empty list using the emptyList() method from the Collections class
        List<string> emptyList = Collections.emptyList();
        // Output a message indicating that an empty list has been created
        System.out.println("An immutable empty list has been created: " + emptyList);
        try {
            // Attempt to add an element to the empty list, which should raise an UnsupportedOperationException
            emptyList.add("item"); // This operation should throw an exception
        } catch (UnsupportedOperationException e) {
            // Output a message indicating that an attempt to modify the empty list has failed
            System.out.println("Failed to modify the empty list: " + e.getMessage());
        }
        // Check if the empty list is still empty
        System.out.println("Is the empty list still empty? " + emptyList.isEmpty());
        try {
            // Attempt to clear the empty list, which should raise an UnsupportedOperationException
            emptyList.clear(); // This operation should throw an exception
        } catch (UnsupportedOperationException e) {
            // Output a message indicating that an attempt to clear the empty list has failed
            System.out.println("Failed to clear the empty list: " + e.getMessage());
        }
        // Demonstrate that the emptyList() method returns the same instance of an empty list
        List<string> anotherEmptyList = Collections.emptyList();
        System.out.println("Are both empty lists the same instance? " + (emptyList == anotherEmptyList));
        try {
            // Attempt to modify the second empty list, which should raise an UnsupportedOperationException
            anotherEmptyList.add("another item"); // This operation should throw an exception
        } catch (UnsupportedOperationException e) {
            // Output a message indicating that an attempt to modify the second empty list has failed
            System.out.println("Failed to modify the second empty list: " + e.getMessage());
        }
        // Check if the second empty list is still empty
        System.out.println("Is the second empty list still empty? " + anotherEmptyList.isEmpty());
        // Output the second empty list after attempted modifications
        System.out.println("Second empty list after attempted modifications: " + anotherEmptyList);
    }
}
</string></string>

Output:

An immutable empty list has been created: []
Failed to modify the empty list: null
Is the empty list still empty? true
Are both empty lists the same instance? true
Failed to modify the second empty list: null
Is the second empty list still empty? true
Second empty list after attempted modifications: []

In summary, the Collections.emptyList() method is a convenient way to obtain an immutable empty list in Java, useful for scenarios where you need an empty list that cannot be modified.

Next TopicJava Collections Class

← prev next →