¿Cómo eliminar todos los elementos nulos de una ArrayList o String Array?

Lo intento con un bucle como ese

// ArrayList tourists

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

Pero no es lindo. ¿Alguien puede sugerirme una mejor solución?

Algunos puntos de referencia útiles para tomar una mejor decisión:

Bucle While, bucle For y prueba de rendimiento del iterador

Tratar:

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

Lea la API de Java . El código se lanzará java.lang.UnsupportedOperationExceptionpara listas inmutables (como las creadas con Arrays.asList); Vea esta respuesta para más detalles.

A partir de 2015, esta es la mejor manera (Java 8):

tourists.removeIf(Objects::isNull);

Nota: Este código arrojará java.lang.UnsupportedOperationExceptionpara listas de tamaño fijo (como las creadas con Arrays.asList), incluidas las listas inmutables.

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

Será Lanza UnsupportedException si lo usa en Arrays.asList, ya que le dan Inmutable copia por lo que no se puede modificar. Ver abajo el código. Crea una copia mutable y no arrojará ninguna excepción.

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()]);
}

No eficiente, pero corto

while(tourists.remove(null));

Si prefiere objetos de datos inmutables, o si simplemente no desea ser destructivo para la lista de entrada, puede usar los predicados de Guava.

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

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

Pre-Java 8 debe usar:

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

Uso posterior a Java 8:

tourists.removeIf(Objects::isNull);

La razón aquí es la complejidad del tiempo. El problema con las matrices es que una operación de eliminación puede tardar O (n) en completarse. Realmente en Java, esta es una copia de matriz de los elementos restantes que se mueven para reemplazar el espacio vacío. Muchas otras soluciones que se ofrecen aquí desencadenarán este problema. El primero es técnicamente O (n * m) donde m es 1 porque es un singleton nulo: entonces O (n)

Debe eliminar All of the singleton, internamente hace un batchRemove () que tiene una posición de lectura y una posición de escritura. E itera la lista. Cuando llega a un valor nulo, simplemente itera la posición de lectura en 1. Cuando son lo mismo que pasa, cuando son diferentes, se sigue moviendo copiando los valores. Luego, al final, se ajusta al tamaño.

Efectivamente hace esto 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();
    }
}

Lo que puede ver explícitamente es una operación O (n).

Lo único que podría ser más rápido es si itera la lista desde ambos extremos, y cuando encuentra un valor nulo, establece su valor igual al valor que encontró al final y disminuye ese valor. E iterado hasta que los dos valores coinciden. Arruinaría el orden, pero reduciría enormemente la cantidad de valores que establezca frente a los que dejó solo. Es un buen método para saber, pero no ayudará mucho aquí, ya que .set () es básicamente gratuito, pero esa forma de eliminar es una herramienta útil para su cinturón.

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

Si bien esto parece bastante razonable, el .remove () en el iterador llama internamente:

ArrayList.this.remove(lastRet);

Que es nuevamente la operación O (n) dentro de la eliminación. Hace un System.arraycopy () que nuevamente no es lo que quieres, si te importa la velocidad. Esto lo hace n ^ 2.

También hay:

while(tourists.remove(null));

Que es O (m * n ^ 2). Aquí no solo iteramos la lista. Reiteramos toda la lista, cada vez que hacemos coincidir el nulo. Luego hacemos n / 2 (promedio) operaciones para hacer System.arraycopy () para realizar la eliminación. Literalmente, podría ordenar toda la colección entre elementos con valores y elementos con valores nulos y recortar el final en menos tiempo. De hecho, eso es cierto para todos los rotos. Al menos en teoría, el system.arraycopy real no es en realidad una operación N en la práctica. En teoría, teoría y práctica son lo mismo; en la práctica no lo son.

Hay una manera fácil de eliminar todos los nullvalores de collection. Debe pasar una colección que contenga nulo como parámetro al removeAll()método

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

yourCollection.removeAll(s1);

La Objectsclase tiene una con la nonNull Predicateque se puede usar filter.

Por ejemplo:

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

Usando Java 8, puedes hacer esto usando stream()yfilter()

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

o

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

Para más información: Java 8 - Streams

Esta es una manera fácil de eliminar los valores nulos predeterminados de la lista de arrays

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

de lo contrario, el valor de cadena "nulo" se eliminará de la lista de arrays

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

Jugué con esto y descubrí que trimToSize () parece funcionar. Estoy trabajando en la plataforma Android, por lo que podría ser diferente.

Podemos usar el iterador para lo mismo para eliminar todos los valores nulos.

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

Utilicé la interfaz de flujo junto con la operación de flujo por cobrar y un método auxiliar para generar una nueva lista.

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

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

Principalmente estoy usando esto:

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

Pero después de aprender Java 8, cambié a esto:

List.removeIf(Objects::isNull);

Usando Java 8 esto se puede realizar de varias maneras usando flujos, flujos paralelos y 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]

El flujo paralelo hará uso de los procesadores disponibles y acelerará el proceso para listas de tamaño razonable. Siempre es recomendable realizar una evaluación comparativa antes de usar transmisiones.

Similar a la respuesta @Lithium pero no arroja un error "La lista no puede contener 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);