Wie entferne ich alle Nullelemente aus einer ArrayList oder einem String-Array?

Ich versuche es mit einer solchen Schleife

// ArrayList tourists

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

Aber es ist nicht schön. Kann mir jemand eine bessere Lösung vorschlagen?

Einige nützliche Benchmarks, um eine bessere Entscheidung zu treffen:

While-Schleife, For-Schleife und Iterator-Leistungstest

Versuchen:

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

Lesen Sie die Java-API . Der Code löst java.lang.UnsupportedOperationExceptionunveränderliche Listen aus (z. B. erstellt mit Arrays.asList). Weitere Informationen finden Sie in dieser Antwort .

Ab 2015 ist dies der beste Weg (Java 8):

tourists.removeIf(Objects::isNull);

Hinweis: Dieser Code wird java.lang.UnsupportedOperationExceptionfür Listen mit fester Größe (z. B. mit Arrays.asList erstellt) einschließlich unveränderlicher Listen ausgegeben.

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

Es wird eine nicht unterstützte Ausnahme ausgelöst, wenn Sie sie in Arrays.asList verwenden, da Sie eine unveränderliche Kopie erhalten, sodass sie nicht geändert werden kann. Siehe unten den Code. Es schafft Mutable Kopie und wird keine Ausnahme ausgelöst.

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

Nicht effizient, aber kurz

while(tourists.remove(null));

Wenn Sie unveränderliche Datenobjekte bevorzugen oder die Eingabeliste nicht destruktiv beeinflussen möchten, können Sie die Prädikate von Guava verwenden.

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

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

Vor Java 8 sollten Sie Folgendes verwenden:

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

Verwendung nach Java 8:

tourists.removeIf(Objects::isNull);

Der Grund hierfür ist die zeitliche Komplexität. Das Problem bei Arrays besteht darin, dass ein Entfernungsvorgang O (n) Zeit in Anspruch nehmen kann. In Java ist dies eine Array-Kopie der verbleibenden Elemente, die verschoben werden, um die leere Stelle zu ersetzen. Viele andere hier angebotene Lösungen lösen dieses Problem aus. Ersteres ist technisch gesehen O (n * m), wobei m 1 ist, weil es eine Singleton-Null ist: also O (n)

Sie solltenAlle Singleton entfernen, intern führt es einen batchRemove () aus, der eine Lese- und eine Schreibposition hat. Und iteriert die Liste. Wenn es eine Null trifft, iteriert es einfach die Leseposition um 1. Wenn sie gleich sind, passiert es, wenn sie unterschiedlich sind, fährt es fort, die Werte zu kopieren. Am Ende wird es dann zugeschnitten.

Dies geschieht effektiv intern:

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

Was Sie explizit sehen können, ist eine O (n) -Operation.

Das einzige, was jemals schneller sein könnte, ist, wenn Sie die Liste von beiden Seiten iterieren und wenn Sie eine Null gefunden haben, setzen Sie ihren Wert gleich dem Wert, den Sie am Ende gefunden haben, und dekrementieren Sie diesen Wert. Und iteriert, bis die beiden Werte übereinstimmen. Sie würden die Reihenfolge durcheinander bringen, aber die Anzahl der von Ihnen festgelegten Werte im Vergleich zu denen, die Sie alleine gelassen haben, erheblich reduzieren. Dies ist eine gute Methode, die Sie kennen sollten, die hier jedoch nicht viel hilft, da .set () grundsätzlich kostenlos ist. Diese Form des Löschens ist jedoch ein nützliches Werkzeug für Ihren Gürtel.

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

Während dies vernünftig erscheint, ruft die .remove () auf dem Iterator intern auf:

ArrayList.this.remove(lastRet);

Welches ist wieder die O (n) -Operation innerhalb der Entfernung. Es führt eine System.arraycopy () durch, die wiederum nicht Ihren Wünschen entspricht, wenn Sie Wert auf Geschwindigkeit legen. Dies macht es n ^ 2.

Es gibt auch:

while(tourists.remove(null));

Welches ist O (m * n ^ 2). Hier iterieren wir nicht nur die Liste. Wir wiederholen die gesamte Liste jedes Mal, wenn wir mit der Null übereinstimmen. Dann führen wir n / 2 (durchschnittliche) Operationen aus, um die System.arraycopy () durchzuführen, um das Entfernen durchzuführen. Sie können buchstäblich die gesamte Sammlung zwischen Elementen mit Werten und Elementen mit Nullwerten sortieren und das Ende in kürzerer Zeit kürzen. In der Tat gilt das für alle kaputten. Zumindest theoretisch ist die eigentliche system.arraycopy in der Praxis keine N-Operation. In Theorie, Theorie und Praxis sind dasselbe; in der Praxis sind sie nicht.

Es gibt eine einfache Möglichkeit, alle nullWerte aus zu collectionentfernen. Sie müssen eine Auflistung mit null als Parameter an die removeAll()Methode übergeben

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

yourCollection.removeAll(s1);

Die ObjectsKlasse hat eine nonNull Predicate, mit der verwendet werden kann filter.

Beispielsweise:

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

Mit Java 8 können Sie dies mit stream()und tunfilter()

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

oder

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

Für weitere Informationen: Java 8 - Streams

Dies ist eine einfache Möglichkeit, Standard-Nullwerte aus der Arrayliste zu entfernen

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

Andernfalls wird der Zeichenfolgenwert "null" aus der Arrayliste entfernt

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

Ich habe damit herumgespielt und herausgefunden, dass trimToSize () zu funktionieren scheint. Ich arbeite an der Android-Plattform, daher könnte es anders sein.

Wir können den Iterator für denselben verwenden, um alle Nullwerte zu entfernen.

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

Ich habe die Stream-Schnittstelle zusammen mit der Stream-Operation Collect und einer Hilfsmethode verwendet, um eine neue Liste zu erstellen .

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

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

Hauptsächlich benutze ich das:

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

Aber nachdem ich Java 8 gelernt hatte, wechselte ich zu folgendem:

List.removeIf(Objects::isNull);

Mit Java 8 kann dies auf verschiedene Arten mithilfe von Streams, parallelen Streams und removeIfMethoden durchgeführt werden:

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]

Der parallele Stream verwendet verfügbare Prozessoren und beschleunigt den Prozess für Listen mit angemessener Größe. Es ist immer ratsam, vor der Verwendung von Streams ein Benchmarking durchzuführen.

Ähnlich wie bei der Antwort von @Lithium, aber es wird kein Fehler "Liste darf keinen Typ null enthalten" ausgegeben:

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