Why would someone use Collections.emptyList in java? [duplicate]

Answer 1

Being immutable allows for reusable instances.

Collections.emptyList will always return the exact same singleton instance.

This is very efficient.

In addition to that, immutable data can be safely shared between threads, and is guaranteed to avoid weird side-effects due to coding errors. For that reason it makes defensive copies unnecessary, too.

Answer 2

Say you have to return a collection and you don't want to creating a couple of objects each time.

interface Configurable {
    List<String> getConfigurationList();
}

// class which doesn't have any configuration
class SimpleConfigurable implements Configurable {
    public List<String> getConfigurationList() { return Collections.emptyList(); }
}

Returning an empty collection is often preferable to returning null

Answer 3

I often use empty lists as Null objects: this avoid having to check for null.

Answer 4

I've used Collections.emptyList for methods that return a list but that are called with arguments that don't make sense.

For instance a stream processing application where you want to access different parts of the stream, perhaps based on dates. You query for a time span of items from the stream but if there are no items in that time span you would return an empty list. Throwing an exception wouldn't make any sense since the isn't anything wrong with the query. Returning null also doesn't make much sense because then all the calling code needs to check for null.

Returning an immutable empty list allows the calling code the handle the return value nicely, you don't need to worry about threading issues since an immutable list is inherently thread safe.

Answer 5

To avoid Unwanted NullPointerException.

In your code, you may return a normal "empty" ArrayList instead of returning null. But, in that way, you will keep creating NEW objects (with default capacity of 10) on each execution which is not a memory efficient approach. Instead of that if you return emptyList, the same instance will be returned on every invocation. This way it saves you from unwanted NullPointerException in a more efficient way. Here is the snip from the Javadoc for emptyList:

/**
 * Returns the empty list (immutable).  This list is serializable.
 *
 * <p>This example illustrates the type-safe way to obtain an empty list:
 * <pre>
 *     List&lt;String&gt; s = Collections.emptyList();
 * </pre>
 * Implementation note:  Implementations of this method need not
 * create a separate <tt>List</tt> object for each call.   Using this
 * method is likely to have comparable cost to using the like-named
 * field.  (Unlike this method, the field does not provide type safety.)
 *
 * @see #EMPTY_LIST
 * @since 1.5
 */