Collections.emptyList () vs. nueva instancia

En la práctica, es mejor devolver una lista vacía como esta :

return Collections.emptyList();

O como esta :

return new ArrayList<Foo>();

¿O depende completamente de lo que va a hacer con la lista devuelta?

La principal diferencia es que Collections.emptyList()devuelve una lista inmutable , es decir, una lista a la que no puede agregar elementos. (Lo mismo se aplica a lo List.of()introducido en Java 9.)

En los raros casos en que no desea modificar la lista devuelta, Collections.emptyList()y List.of()por lo tanto son no unas buenas opciones.

Yo diría que devolver una lista inmutable está perfectamente bien (e incluso la forma preferida) siempre que el contrato (documentación) no establezca de manera explícita de manera diferente.

Además, emptyList() podría no crear un nuevo objeto con cada llamada.

Las implementaciones de este método no necesitan crear un objeto List separado para cada llamada. Es probable que el uso de este método tenga un costo comparable al uso del campo con el mismo nombre. (A diferencia de este método, el campo no proporciona seguridad de tipo).

La implementación de emptyListlooks de la siguiente manera:

public static final <T> List<T> emptyList() {
    return (List<T>) EMPTY_LIST;
}

Entonces, si su método (que devuelve una lista vacía) se llama con mucha frecuencia, este enfoque puede incluso brindarle un rendimiento ligeramente mejor tanto en CPU como en memoria.

Comenzando con Java 5.0, puede especificar el tipo de elemento en el contenedor:

Collections.<Foo>emptyList()

Estoy de acuerdo con las otras respuestas de que para los casos en que desea devolver una lista vacía que permanezca vacía, debe usar este enfoque.

Collections.emptyList es inmutable, por lo que hay una diferencia entre las dos versiones, por lo que debe considerar a los usuarios del valor devuelto.

La devolución new ArrayList<Foo>siempre crea una nueva instancia del objeto, por lo que tiene un costo adicional muy pequeño asociado, lo que puede darle una razón para usarlo Collections.emptyList. Me gusta usar emptyListsolo porque es más legible.

Pero ten cuidado. Si regresa Collections.emptyList()y luego intenta hacer algunos cambios con él como add()o algo así, tendrá un UnsupportedOperationException()porque Collections.emptyList()devuelve un objeto inmutable.

Iría con Collections.emptyList()si la lista devuelta no se modifica de ninguna manera (ya que la lista es inmutable), de lo contrario iría con la opción 2.

El beneficio de Collections.emptyList()es que la misma instancia estática se devuelve cada vez y, por lo tanto, no se produce una creación de instancia para cada llamada.

Use Collections.emptyList () si desea asegurarse de que la lista devuelta nunca se modifique. Esto es lo que se devuelve al llamar a emptyList ():

/**
 * The empty list (immutable). 
 */
public static final List EMPTY_LIST = new EmptyList();

Las respuestas dadas enfatizan el hecho de que emptyList()devuelve un valor inmutable Listpero no dan alternativas. Los ArrayList(int initialCapacity)casos especiales de Constructor , 0por lo que regresar en new ArrayList<>(0)lugar de new ArrayList<>()también podría ser una solución viable:

/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

[...]

/**
 * Constructs an empty list with the specified initial capacity.
 *
 * @param  initialCapacity  the initial capacity of the list
 * @throws IllegalArgumentException if the specified initial capacity
 *         is negative
 */
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

(fuentes de Java 1.8.0_72)