Collections.emptyList () vs. nuova istanza

In pratica, è meglio restituire un elenco vuoto come questo :

return Collections.emptyList();

O come questo :

return new ArrayList<Foo>();

O dipende completamente da cosa hai intenzione di fare con l'elenco restituito?

La differenza principale è che Collections.emptyList()restituisce un elenco immutabile , ovvero un elenco a cui non è possibile aggiungere elementi. (Lo stesso vale per l' List.of()introduzione in Java 9.)

Nei rari casi in cui si fa desidera modificare la lista restituita, Collections.emptyList()e List.of()sono quindi non una buona scelta.

Direi che la restituzione di un elenco immutabile va benissimo (e persino nel modo preferito) purché il contratto (documentazione) non sia esplicitamente indicato diversamente.

Inoltre, emptyList() potrebbe non creare un nuovo oggetto con ogni chiamata.

Le implementazioni di questo metodo non devono creare un oggetto Elenco separato per ogni chiamata. L'uso di questo metodo avrà probabilmente costi comparabili rispetto all'utilizzo del campo con nomi simili. (A differenza di questo metodo, il campo non fornisce la sicurezza del tipo.)

L'implementazione di emptyListsembra come segue:

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

Quindi, se il tuo metodo (che restituisce un elenco vuoto) viene chiamato molto spesso, questo approccio potrebbe persino darti prestazioni leggermente migliori sia per la CPU che per la memoria.

A partire da Java 5.0 è possibile specificare il tipo di elemento nel contenitore:

Collections.<Foo>emptyList()

Concordo con le altre risposte che per i casi in cui si desidera restituire un elenco vuoto che rimane vuoto, è necessario utilizzare questo approccio.

Collections.emptyList è immutabile, quindi esiste una differenza tra le due versioni, quindi è necessario considerare gli utenti del valore restituito.

Il ritorno new ArrayList<Foo>crea sempre una nuova istanza dell'oggetto in modo che abbia un leggero costo aggiuntivo associato che potrebbe darti un motivo per usarlo Collections.emptyList. Mi piace usare emptyListsolo perché è più leggibile.

Stai attento però. Se ritorni Collections.emptyList()e poi provi a fare alcune modifiche con esso add()o smth in quel modo, avrai un UnsupportedOperationException()perché Collections.emptyList()restituisce un oggetto immutabile.

Vorrei andare con Collections.emptyList() se l'elenco restituito non viene modificato in alcun modo (poiché l'elenco è immutabile), altrimenti andrei con l'opzione 2.

Il vantaggio Collections.emptyList()è che la stessa istanza statica viene restituita ogni volta e quindi non si verifica la creazione dell'istanza per ogni chiamata.

Utilizzare Collections.emptyList () se si desidera assicurarsi che l'elenco restituito non venga mai modificato. Questo è ciò che viene restituito quando si chiama emptyList ():

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

Le risposte fornite sottolineano il fatto che emptyList()restituisce un valore immutabile Listma non danno alternative. I ArrayList(int initialCapacity)casi speciali del costruttore , 0quindi tornare al new ArrayList<>(0)posto di new ArrayList<>()potrebbe anche essere una soluzione praticabile:

/**
 * 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);
    }
}

(fonti da Java 1.8.0_72)