¿Cómo eliminar todos los elementos null de una matriz ArrayList o String?

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

tourists.removeIf(Objects::isNull);

Nota: Este código lanzará java.lang.UnsupportedOperationException para listas de tamaño fijo (como las creadas con matrices.asList), incluyendo listas inmutables.

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

Lanzará UnsupportedException si lo usa en matrices.asList porque te da copia inmutable para que no se pueda modificar. Ver a continuación el código. Crea copia mutable y no lanzará 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 quiere ser destructivo para la lista de entrada, puede usar predicados de Guayaba.

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

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

Hay una manera fácil de eliminar todos los valores null de collection.Debe pasar una colección que contenga null como parámetro a removeAll() method

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

yourCollection.removeAll(s1);

La clase Objects tiene un nonNull Predicate que se puede utilizar con filter.

Por ejemplo:

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

Usando Java 8, puedes hacer esto usando stream() y filter()

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-Flujos

Esta es una manera fácil de eliminar los valores nulos predeterminados de arraylist

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

De lo contrario, el valor de cadena "null" se elimina de arraylist

       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 el mismo para eliminar todos los valores null.

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

Utilicé la interfaz stream junto con la operación stream collect y un método helper para generar una nueva lista.

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

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

Pre-Java 8 debes usar:

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

Uso post-Java 8:

tourists.removeIf(Objects::isNull);

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

Debe eliminar todo el 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 null, simplemente itera la posición de lectura por 1. Cuando son iguales pasa, cuando son diferentes sigue moviéndose copiando los valores. Luego al final se recorta a medida.

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

Que se puede ver explícitamente es una operación O(n).

Lo único que podría ser más rápido es si iteró la lista desde ambos extremos, y cuando encontró un null, estableció su valor igual al valor que encontró al final, y decrementó ese valor. E iterado hasta que los dos valores coincidieron. Arruinaría el orden, pero reduciría enormemente el número de valores se establece vs que dejaron solo. Que es un buen método para saber, pero no ayudará mucho aquí como .set() es básicamente gratis, pero esa forma de eliminar es una herramienta útil para tu cinturón.

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

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

ArrayList.this.remove(lastRet);

Que es de nuevo la operación O(n) dentro de la eliminación. Hace un Sistema.arraycopy () que de nuevo 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 repetimos la lista. Reiteramos toda la lista, cada vez que coincidimos con el null. Luego hacemos n / 2 (promedio) operaciones para hacer el Sistema.arraycopy () para realizar la eliminación. Podrías literalmente, ordene toda la colección entre elementos con valores y elementos con valores nulos y recorte el final en menos tiempo. De hecho, eso es cierto para todos los rotos. Al menos en teoría, el sistema real.arraycopy no es realmente una operación N en la práctica. En teoría, teoría y práctica son la misma cosa; en la práctica no lo son.

Usando Java 8 esto se puede realizar de varias maneras usando flujos, flujos paralelos y removeIf mé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 hacer benchmark antes de usar streams.

Similar a la respuesta de @Lithium pero no arroja un error de "La lista no puede contener el tipo null":

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