Collections.emptyList() vs. nuova istanza

Question

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

return Collections.emptyList(); 

O come this:

return new ArrayList<Foo>(); 

O è completamente dipendente cosa farai con la lista restituita?

Answer 1

La differenza principale è che Collections.emptyList() restituisce un immutabile elenco, ad esempio un elenco a cui non è possibile aggiungere elementi.

Nei rari casi in cui l'utente fa desidera modificare l'elenco restituito, ciò non rappresenta un'opzione.

Direi che restituire una lista immutabile è perfettamente soddisfacente (e anche il modo preferito) purché il contratto (documentazione) non dichiari esplicitamente in modo diverso.

---

Inoltre, emptyList()might not create a new object with each call.

implementazioni di questo metodo non è necessario creare un oggetto List separato per ciascuna chiamata. È probabile che l'utilizzo di questo metodo abbia costi comparabili con l'utilizzo del campo con nome simile. (A differenza di questo metodo, il campo non fornisce la sicurezza di tipo.)

L'attuazione di emptyList appare come segue:

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

Quindi, se il metodo (che restituisce una lista vuota) viene chiamato molto spesso , questo approccio potrebbe anche darti prestazioni leggermente migliori sia della CPU che della memoria.

Answer 2

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

Il reso new ArrayList<Foo> restituisce sempre una nuova istanza dell'oggetto in modo che abbia un leggerissimo costo aggiuntivo associato che potrebbe fornire un motivo per utilizzare Collections.emptyList. Mi piace usare emptyList solo perché è più leggibile.

Answer 3

vorrei andare con Collections.emptyList() se l'elenco restituito non viene modificato in alcun modo (come la lista è immutabile), altrimenti andrei con l'opzione 2.

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

Answer 4

partire con 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 vuota, si dovrebbe usare questo approccio.

Answer 5

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

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

Answer 6

Le date risposte sottolineano il fatto che emptyList() restituisce un immutabile List ma non danno alternative. I casi particolari di costruzione ArrayList(int initialCapacity)0 in modo che tornano new ArrayList<>(0) invece 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); 
    } 
} 

(provenienti da sorgenti Java 1.8.0_72)

Answer 7

Stai attento però. Se restituisci Collections.emptyList() e poi prova a fare alcune modifiche con esso come add() o smth del genere, avrai un UnsupportedOperationException() perché Collections.emptyList() restituisce un oggetto immutabile.