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

Question

Trato con un bucle de esa manera

// ArrayList tourists 

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

pero no es agradable. ¿Alguien puede sugerirme una mejor solución?

---

Algunas referencias útiles para hacer una mejor decisión:

While loop, For loop and Iterator Performance Test

Answer 1

Probar:

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

Leer el Java API. El código arrojará java.lang.UnsupportedOperationException para listas inmutables (como las creadas con Arrays.asList); ver this answer para más detalles.

Answer 2

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

Answer 3

no es eficiente, pero corto

while(tourists.remove(null)); 

Answer 4

He jugado un poco con esto y descubrió que TrimToSize() parece funcionar. Estoy trabajando en la plataforma Android, por lo que podría ser diferente.

Answer 5

hay una manera fácil de eliminar todos los valores de nullcollection .tiene tienen que pasar una colección que contiene nulo como un parámetro para removeAll() método

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

yourCollection.removeAll(s1); 

Answer 6

Si prefiere los objetos de datos inmutables, o si simplemente No quiero ser destructivo para la lista de entrada, puedes usar los predicados de Guava.

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

Answer 7

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

It will Throws UnsupportedException if you use it on Arrays.asList because it give you Immutable copy so it can not be modified. See below the code. It creates Mutable copy and will not throw any exception.

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

Answer 8

Ésta es la manera fácil de eliminar los valores nulos por defecto de ArrayList

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

lo contrario valor

cadena "nula" Eliminar de ArrayList

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

Answer 9

Podemos usar iterator para lo mismo para eliminar todos los valores nulos.

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

Answer 10

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

tourists.removeIf(Objects::isNull); 

Nota: Este código tirará java.lang.UnsupportedOperationException para las listas de tamaño fijo (tales como los que crea Arrays.asList), incluidas las listas inmutables.

Answer 11

Utilicé la interfaz de transmisión junto con la operación de secuencia y obtuve 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; 
} 

Answer 12

La clase Objects tiene una nonNullPredicate que se puede utilizar con filter.

Por ejemplo:

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

Answer 13

Uso de Java 8, puede hacerlo utilizando 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 - Streams

Answer 14

Pre-8 de Java que puedes usar:

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

Post-Java 8 uso:

tourists.removeIf(Objects::isNull); 

---

La razón aquí es la complejidad de tiempo. El problema con las matrices es que una operación de eliminación puede tomar O (n) tiempo para completarse. Realmente en Java, esta es una copia de la matriz de los elementos restantes que se mueven para reemplazar la mancha vacía. 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 nulo singleton: así que O (n)

Debe eliminar Todo del singleton, internamente hace un batchRemove() que tiene una posición de lectura y una escribir posición Y repite la lista. Cuando llega a un nulo, simplemente itera la posición de lectura en 1. Cuando pasan lo mismo, cuando son diferentes se mueve a lo largo de la copia de los valores. Luego, al final, se ajusta a medida.

Lo hace efectivamente 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 de forma explícita es un O (n) la operació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 decrementa ese valor. Y se repitió hasta que los dos valores coincidieron. Desordenarías el orden, pero reducirías enormemente el número de valores que estableces frente a los que dejaste solos. Lo cual es un buen método para saber pero no ayudará mucho porque .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 bastante razonable, el .Remove() del iterador llama internamente:

ArrayList.this.remove(lastRet); 

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

Hay también:

while(tourists.remove(null)); 

Qué 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) de operaciones para hacer el System.arraycopy() para realizar la eliminación. Podría literalmente clasificar la colección completa entre elementos con valores y elementos con valores nulos y recortar la terminación 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, la teoría y la práctica son la misma cosa; en la práctica, no lo son.

Answer 15

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

La corriente paralela hará uso de procesadores disponibles y acelerará el proceso de tamaño razonable liza. Siempre es recomendable hacer una evaluación comparativa antes de usar transmisiones.

Answer 16

similares a @Lithium respuesta, pero no lanzar una "lista no puede contener nulos tipo" Error:

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