Como remover todos os elementos nulos de um ArrayList ou String Array?

Eu tento com um laço assim

// ArrayList tourists

for (Tourist t : tourists) {
    if (t != null) {     
        t.setId(idForm); 
    }   
}

Mas não é legal. Alguém pode me sugerir uma solução melhor?

Alguns benchmarks úteis para tomar melhores decisões:

Loop while, For loop e Teste de desempenho do iterador

Experimentar:

tourists.removeAll(Collections.singleton(null));

Leia a API Java . O código será lançado java.lang.UnsupportedOperationExceptionpara listas imutáveis ​​(como criadas com Arrays.asList); veja esta resposta para mais detalhes.

A partir de 2015, esta é a melhor maneira (Java 8):

tourists.removeIf(Objects::isNull);

Nota: Este código será lançado java.lang.UnsupportedOperationExceptionpara listas de tamanho fixo (como criadas com Arrays.asList), incluindo listas imutáveis.

list.removeAll(Collections.singleton(null));

Ele lançará UnsupportedException se você usá-lo em Arrays.asList, pois fornecerá Immutable cópia para que ele não pode ser modificado. Veja abaixo o código. Ele cria uma cópia mutável e não gera nenhuma exceção.

public static String[] clean(final String[] v) {
    List<String> list = new ArrayList<String>(Arrays.asList(v));
    list.removeAll(Collections.singleton(null));
    return list.toArray(new String[list.size()]);
}

Não eficiente, mas curto

while(tourists.remove(null));

Se você preferir objetos de dados imutáveis, ou se não quiser ser destrutivo para a lista de entradas, poderá usar os predicados do Guava.

ImmutableList.copyOf(Iterables.filter(tourists, Predicates.notNull()))

 for (Iterator<Tourist> itr = tourists.iterator(); itr.hasNext();) {
      if (itr.next() == null) { itr.remove(); }
 }

Antes do Java 8, você deve usar:

tourists.removeAll(Collections.singleton(null));

Uso pós-Java 8:

tourists.removeIf(Objects::isNull);

A razão aqui é a complexidade do tempo. O problema com matrizes é que uma operação de remoção pode levar O (n) tempo para ser concluída. Realmente em Java, esta é uma cópia da matriz dos elementos restantes sendo movidos para substituir o ponto vazio. Muitas outras soluções oferecidas aqui acionarão esse problema. O primeiro é tecnicamente O (n * m) onde m é 1 porque é um nulo único: então O (n)

Você deve remover All do singleton, internamente ele faz um batchRemove () que possui uma posição de leitura e uma posição de gravação. E itera a lista. Quando atinge um nulo, ele simplesmente itera a posição de leitura em 1. Quando eles são os mesmos que passam, quando são diferentes, ele continua se movendo ao copiar os valores. Então, no final, apara ao tamanho.

Ele efetivamente faz isso internamente:

public static <E> void removeNulls(ArrayList<E> list) {
    int size = list.size();
    int read = 0;
    int write = 0;
    for (; read < size; read++) {
        E element = list.get(read);
        if (element == null) continue;
        if (read != write) list.set(write, element);
        write++;
    }
    if (write != size) {
        list.subList(write, size).clear();
    }
}

O que você pode ver explicitamente é uma operação O (n).

A única coisa que poderia ser mais rápida é se você iterasse a lista dos dois extremos e, quando encontrasse um nulo, defina seu valor igual ao valor encontrado no final e diminua esse valor. E iterou até que os dois valores correspondessem. Você estragaria o pedido, mas reduziria muito o número de valores que você definiu versus os que você deixou sozinho. Qual é um bom método para saber, mas não ajudará muito aqui, pois .set () é basicamente gratuito, mas essa forma de exclusão é uma ferramenta útil para o seu cinto.

for (Iterator<Tourist> itr = tourists.iterator(); itr.hasNext();) {
      if (itr.next() == null) { itr.remove(); }
 }

Embora isso pareça bastante razoável, o .remove () no iterador chama internamente:

ArrayList.this.remove(lastRet);

Qual é novamente a operação O (n) na remoção. Ele faz um System.arraycopy () que novamente não é o que você deseja, se você se preocupa com a velocidade. Isso torna n ^ 2.

Há também:

while(tourists.remove(null));

Qual é O (m * n ^ 2). Aqui, não apenas iteramos a lista. Reiteramos a lista inteira, sempre que correspondermos ao nulo. Em seguida, fazemos n / 2 (médias) operações para executar o System.arraycopy () para executar a remoção. Você poderia literalmente ordenar a coleção inteira entre itens com valores e itens com valores nulos e aparar o final em menos tempo. De fato, isso é verdade para todos os quebrados. Pelo menos em teoria, o system.arraycopy real não é realmente uma operação N na prática. Em teoria, teoria e prática são a mesma coisa; na prática eles não são.

Existe uma maneira fácil de remover todos os nullvalores de collection.Você precisa passar uma coleção contendo null como parâmetro para o removeAll()método

List s1=new ArrayList();
s1.add(null);

yourCollection.removeAll(s1);

A Objectsclasse tem um nonNull Predicateque pode ser usado comfilter .

Por exemplo:

tourists.stream().filter(Objects::nonNull).collect(Collectors.toList());

Usando o Java 8, você pode fazer isso usando stream()efilter()

tourists = tourists.stream().filter(t -> t != null).collect(Collectors.toList())

ou

tourists = tourists.stream().filter(Objects::nonNull).collect(Collectors.toList())

Para mais informações: Java 8 - Streams

É uma maneira fácil de remover valores nulos padrão do arraylist

     tourists.removeAll(Arrays.asList(null));  

caso contrário, o valor da string "null" remove da arraylist

       tourists.removeAll(Arrays.asList("null"));  

Eu brinquei com isso e descobri que trimToSize () parece funcionar. Estou trabalhando na plataforma Android para que possa ser diferente.

Podemos usar o iterador para remover todos os valores nulos.

Iterator<Tourist> itr= tourists.iterator();
while(itr.hasNext()){
    if(itr.next() == null){
        itr.remove();
    }
}

Usei a interface de fluxo juntamente com a operação de fluxo collect e um método auxiliar para gerar uma nova lista.

tourists.stream().filter(this::isNotNull).collect(Collectors.toList());

private <T> boolean isNotNull(final T item) {
    return  item != null;
}

Principalmente estou usando isso:

list.removeAll(Collections.singleton(null));

Mas depois que aprendi o Java 8, mudei para isso:

List.removeIf(Objects::isNull);

Usando o Java 8, isso pode ser realizado de várias maneiras, usando fluxos, fluxos paralelos e removeIfmétodo:

List<String> stringList = new ArrayList<>(Arrays.asList(null, "A", "B", null, "C", null));
List<String> listWithoutNulls1 = stringList.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList()); //[A,B,C]
List<String> listWithoutNulls2 = stringList.parallelStream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList()); //[A,B,C]
stringList.removeIf(Objects::isNull); //[A,B,C]

O fluxo paralelo utilizará os processadores disponíveis e acelerará o processo para listas de tamanhos razoáveis. É sempre aconselhável fazer benchmark antes de usar fluxos.

Semelhante à resposta @Lithium, mas não gera um erro "A lista não pode conter o tipo nulo":

   list.removeAll(Collections.<T>singleton(null));

List<String> colors = new ArrayList<>(
Arrays.asList("RED", null, "BLUE", null, "GREEN"));
// using removeIf() + Objects.isNull()
colors.removeIf(Objects::isNull);