Controllo null in un ciclo for avanzato

Qual è il modo migliore per proteggersi da null in un ciclo for in Java?

Questo sembra brutto:

if (someList != null) {
    for (Object object : someList) {
        // do whatever
    }
}

O

if (someList == null) {
    return; // Or throw ex
}
for (Object object : someList) {
    // do whatever
}

Potrebbe non esserci altro modo. Avrebbero dovuto inserirlo nel forcostrutto stesso, se è nullo, non eseguire il ciclo?

Dovresti verificare meglio da dove ottieni quell'elenco.

Un elenco vuoto è tutto ciò che serve, perché un elenco vuoto non fallirà.

Se ottieni questo elenco da qualche altra parte e non sai se è ok o no, puoi creare un metodo di utilità e usarlo in questo modo:

for( Object o : safe( list ) ) {
   // do whatever 
 }

E ovviamente safesarebbe:

public static List safe( List other ) {
    return other == null ? Collections.EMPTY_LIST : other;
}

Potresti potenzialmente scrivere un metodo helper che ha restituito una sequenza vuota se hai passato null:

public static <T> Iterable<T> emptyIfNull(Iterable<T> iterable) {
    return iterable == null ? Collections.<T>emptyList() : iterable;
}

Quindi utilizzare:

for (Object object : emptyIfNull(someList)) {
}

Non penso che lo farei comunque, di solito uso la tua seconda forma. In particolare, "o buttare ex" è importante - se davvero non dovrebbe essere nullo, dovresti assolutamente lanciare un'eccezione. Sai che qualcosa è andato storto, ma non conosci l'entità del danno. Interrompi presto.

È già il 2017 e ora puoi utilizzare Apache Commons Collections4

L'utilizzo:

for(Object obj : ListUtils.emptyIfNull(list1)){
    // Do your stuff
}

Puoi fare lo stesso controllo null-safe con le altre classi Collection con CollectionUtils.emptyIfNull.

Con Java 8 Optional:

for (Object object : Optional.ofNullable(someList).orElse(Collections.emptyList())) {
    // do whatever
}

Utilizzare ArrayUtils.nullToEmptydalla commons-langlibreria per le matrici

for( Object o : ArrayUtils.nullToEmpty(list) ) {
   // do whatever 
}

Questa funzionalità esiste nella commons-langlibreria, inclusa nella maggior parte dei progetti Java.

// ArrayUtils.nullToEmpty source code 
public static Object[] nullToEmpty(final Object[] array) {
    if (isEmpty(array)) {
        return EMPTY_OBJECT_ARRAY;
    }
    return array;
}

// ArrayUtils.isEmpty source code
public static boolean isEmpty(final Object[] array) {
    return array == null || array.length == 0;
}

Questa è la stessa della risposta data da @OscarRyz, ma per il bene del mantra DRY , credo che valga la pena notare. Vedi la pagina del progetto commons-lang . Ecco la documentazione e l' originenullToEmpty API

Voce Maven da includere commons-langnel progetto se non lo è già.

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.4</version>
</dependency>

Sfortunatamente, commons-langnon fornisce questa funzionalità per i Listtipi. In questo caso dovresti usare un metodo di supporto come menzionato in precedenza.

public static <E> List<E> nullToEmpty(List<E> list)
{
    if(list == null || list.isEmpty())
    {
        return Collections.emptyList();
    }
    return list;
}

Se lo si ottiene Listda una chiamata di metodo implementata, quindi non tornare null, restituire uno spazio vuoto List.

Se non riesci a modificare l'implementazione, allora sei bloccato con il nullcontrollo. Se non dovrebbe essere null, quindi getta un'eccezione.

Non sceglierei il metodo helper che restituisce un elenco vuoto perché potrebbe essere utile alcune volte, ma poi ti abitueresti a chiamarlo in ogni ciclo che potresti nascondere nascondendo alcuni bug.

Ho modificato la risposta sopra, quindi non è necessario eseguire il cast da Object

public static <T> List<T> safeClient( List<T> other ) {
            return other == null ? Collections.EMPTY_LIST : other;
}

e quindi chiama semplicemente la lista di

for (MyOwnObject ownObject : safeClient(someList)) {
    // do whatever
}

Spiegazione: MyOwnObject: List<Integer>in tal caso MyOwnObject sarà integer in questo caso.

Un altro modo per proteggersi efficacemente da un null in un ciclo for è quello di avvolgere la tua raccolta con Google Guava Optional<T>poiché questo, si spera, rende chiara la possibilità di una raccolta effettivamente vuota poiché il cliente dovrebbe verificare se la raccolta è presente Optional.isPresent().

Per chiunque non sia interessato a scrivere il proprio metodo di sicurezza nulla statico è possibile utilizzare: commons-lang's org.apache.commons.lang.ObjectUtils.defaultIfNull(Object, Object). Per esempio:

    for (final String item : 
    (List<String>)ObjectUtils.defaultIfNull(items, Collections.emptyList())) { ... }

ObjectUtils.defaultIfNull JavaDoc

Utilizzare un CollectionUtils.isEmpty(Collection coll)metodo che sia Null-safe se la raccolta specificata è vuota.

per questo import org.apache.commons.collections.CollectionUtils.

Dipendenza da Maven

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.0</version>
</dependency>

for (Object object : someList) {

   // do whatever
}  throws the null pointer exception.