Verificação nula em um loop for aprimorado

Qual é a melhor maneira de proteger contra null em um loop for em Java?

Isso parece feio:

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

Ou

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

Pode não haver outro jeito. Eles devem colocá-lo na construção for, se for nulo, então não execute o loop?

Você deve verificar melhor de onde você tira essa lista.

Uma lista vazia é tudo que você precisa, porque uma lista vazia não falhará.

Se você pegar essa lista de algum outro lugar e não souber se está tudo bem ou não, você pode criar um método utilitário e usá-lo assim:

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

E, claro, safe seria:

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

Você poderia escrever um método auxiliar que retornasse uma seqüência vazia se você passasse em null:

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

Então use:

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

Eu não acho que eu realmente faria isso – normalmente eu usaria sua segunda forma. Em particular, o “ou jogar ex” é importante – se realmente não deveria ser nulo, você definitivamente deveria lançar uma exceção. Você sabe que algo deu errado, mas você não sabe a extensão do dano. Abortar cedo.

Já é de 2017, e agora você pode usar o Apache Commons Collections4

O uso:

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

Você pode fazer a mesma verificação de segurança nula para outras classs CollectionUtils.emptyIfNull com CollectionUtils.emptyIfNull .

TL; DR Use ArrayUtils.nullToEmpty da biblioteca commons-lang para Arrays

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

Essa funcionalidade existe na biblioteca commons-lang , incluída na maioria dos projetos 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; } 

Isto é o mesmo que a resposta dada por @OscarRyz, mas por causa do mantra DRY , eu acredito que vale a pena notar. Veja a página do projeto commons-lang . Aqui está a documentação e a origem da API nullToEmpty

Entrada Maven para include commons-lang em seu projeto, se ainda não o é.

  org.apache.commons commons-lang3 3.4  

Infelizmente, o commons-lang não oferece essa funcionalidade para os tipos de List . Nesse caso, você teria que usar um método auxiliar conforme mencionado anteriormente.

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

Se você estiver obtendo essa List de uma chamada de método implementada, não retorne null , retorne uma List vazia.

Se você não pode alterar a implementação, então você está preso com a verificação null . Se não deve ser null , então lance uma exceção.

Eu não iria para o método auxiliar que retorna uma lista vazia, porque pode ser útil algumas vezes, mas então você se acostumaria a chamá-lo em cada loop que você faz, possivelmente escondendo alguns bugs.

Eu modifiquei a resposta acima, para que você não precise converter de Objeto

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

e depois simplesmente chame a Lista por

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

Explanation: MyOwnObject: Se List então MyOwnObject será Integer neste caso.

Com o Java 8 Optional :

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

Outra maneira de proteger-se efetivamente contra um nulo em um loop é agrupar sua coleção com o Optional Google Guava, pois, espera-se, isso torna clara a possibilidade de uma coleção efetivamente vazia, já que o cliente deve verificar se a coleção está presente com Optional.isPresent() .

Para qualquer pessoa desinteressada em escrever seu próprio método de segurança estático, você pode usar: org.apache.commons.lang.ObjectUtils.defaultIfNull(Object, Object) commons-lang. Por exemplo:

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

ObjectUtils.defaultIfNull JavaDoc

Use, CollectionUtils.isEmpty(Collection coll) método que é verificação Null-safe se a coleção especificada estiver vazia.

para esta import org.apache.commons.collections.CollectionUtils .

Dependência Maven

  org.apache.commons commons-collections4 4.0  
 for (Object object : someList) { // do whatever } throws the null pointer exception.