webentwicklung-frage-antwort-db.com.de

Entfernen Sie in Java leere Elemente aus einer Liste von Strings

In Java habe ich eine ArrayList von Strings wie:

[,Hi, ,How,are,you]

Ich möchte die leeren und leeren Elemente entfernen, wie man sie so ändert, dass es so ist:

[Hi,How,are,you]
43
Niranjan Kumar
List<String> list = new ArrayList<String>(Arrays.asList("", "Hi", null, "How"));
System.out.println(list);
list.removeAll(Arrays.asList("", null));
System.out.println(list);

Ausgabe:

[, Hi, null, How]
[Hi, How]
76
smas

Es ist eine sehr späte Antwort, aber Sie können auch den Collections.singleton verwenden:

List<String> list = new ArrayList<String>(Arrays.asList("", "Hi", null, "How"));
list.removeAll(Collections.singleton(null));
list.removeAll(Collections.singleton(""));
37
tokhi

Eine andere Möglichkeit, dies jetzt zu tun, da wir Java 8-Lambda-Ausdrücke haben.

arrayList.removeIf(item -> item == null || "".equals(item));
12
Andrew Mairose
  1. Wenn Sie how nach dem Entfernen der leeren Zeichenfolgen gefragt haben, können Sie dies wie folgt tun (wobei l ein ArrayList<String> ist). Dadurch werden alle null-Referenzen und Zeichenfolgen der Länge 0 entfernt:

    Iterator<String> i = l.iterator();
    while (i.hasNext())
    {
        String s = i.next();
        if (s == null || s.isEmpty())
        {
            i.remove();
        }
    }
    
  2. Verwechseln Sie keine ArrayList mit Arrays. Eine ArrayList ist eine dynamische Datenstruktur, deren Größe sich nach ihrem Inhalt richtet. Wenn Sie den obigen Code verwenden, müssen Sie nichts tun, um das Ergebnis zu erhalten, wie Sie es beschrieben haben - wenn Ihre ArrayList ["", "Hallo", "", "Wie", "Wie", " Sie "], nach dem Entfernen wie oben, wird es genau das sein, was Sie brauchen - ["Hi","How","are","you"].

    Wenn Sie jedoch müssen über eine 'bereinigte' Kopie der ursprünglichen Liste verfügen (und dabei das Original unverändert lassen) und mit 'store it' meinen Sie 'make a copy ', dann wird der Code von krmby in der anderen Antwort gut funktionieren.

7

Es gibt einige Ansätze, die Sie verwenden könnten:

  1. Durchlaufen Sie die Liste und rufen Sie Iterator.remove() für die Listenelemente auf, die Sie entfernen möchten. Das ist das einfachste.

  2. Rufen Sie wiederholt List.remove(Object) auf. Dies ist auch einfach, führt jedoch zu den schlechtesten Ergebnissen, da Sie wiederholt die gesamte Liste scannen. (Dies kann jedoch eine Option für eine veränderliche Liste sein, deren Iterator remove ... aus irgendeinem Grund nicht unterstützt hat.)

  3. Erstellen Sie eine neue Liste, durchlaufen Sie die alte Liste und fügen Sie der neuen Liste Elemente hinzu, die Sie beibehalten möchten. 

  4. Wenn Sie die neue Liste nicht wie oben beschrieben zurückgeben können, löschen Sie die alte Liste und verwenden Sie addAll, um die Elemente der neuen Liste wieder hinzuzufügen.

Welche davon am schnellsten ist, hängt von der Klasse der ursprünglichen Liste, deren Größe und der Anzahl der Elemente ab, die entfernt werden müssen. Hier sind einige der Faktoren:

  • Bei einer ArrayList ist jede einzelne remove-Operation O(N), wobei N die Listengröße ist. Das Entfernen mehrerer Elemente aus einer großen ArrayList ist mit der Methode Iterator.remove() (oder der Methode ArrayList.remove(element)) teuer. 

    Im Gegensatz dazu ist die Iterator.remove-Methode für eine LinkedListO(1).

  • Das Erstellen und Kopieren einer Liste ist für ArrayListO(N) und relativ _ cheap, insbesondere wenn Sie sicherstellen können, dass die Kapazität der Zielliste ausreichend groß ist (jedoch nicht zu groß).

    Das Erstellen und Kopieren in eine LinkedList ist dagegen ebenfalls O(N), jedoch erheblich teurer.

All dies führt zu einem ziemlich komplizierten Entscheidungsbaum. Wenn die Listen klein sind (z. B. 10 oder weniger Elemente), können Sie wahrscheinlich mit einem der oben genannten Ansätze davonkommen. Wenn die Listen umfangreich sein könnten, müssen Sie alle Probleme in der Liste der erwarteten Listengröße und der erwarteten Anzahl von Entfernungen abwägen. (Andernfalls erhalten Sie möglicherweise eine quadratische Leistung.)

4
Stephen C
  • Dieser Code wird kompiliert und läuft reibungslos.
  • Es verwendet keinen Iterator, der besser lesbar ist.
  • liste ist Ihre Sammlung.
  • ergebnis ist gefilterte Form (keine Null, keine leeren).

public static void listRemove() {
    List<String> list = Arrays.asList("", "Hi", "", "How", "are", "you");
    List<String> result = new ArrayList<String>();

    for (String str : list) {
        if (str != null && !str.isEmpty()) {
            result.add(str);
        }
    }

    System.out.println(result);
}
3
Kerem Baydoğan

Wenn Sie UnsupportedOperationException von einer der obigen Antworten erhalten und Ihre List aus Arrays.asList() erstellt wird, liegt dies daran, dass Sie diese List nicht bearbeiten können.

Um das Problem zu beheben, wickeln Sie die Arrays.asList() in new LinkedList<String>() ein:

    List<String> list = new LinkedList<String>(Arrays.asList(split));

Quelle ist von dieser Antwort .

2
AnT

Ich werde dieses kleine Nugget hier reinlassen:

Stream.of("", "Hi", null, "How", "are", "you")
  .filter(t -> !Strings.isNullOrEmpty(t))
  .collect(ImmutableList.toImmutableList());

Ich wünsche mir von ganzem Herzen, dass Java eine filterNot hatte.

2
Sam Berry

Wenn Sie Java 8 verwenden, versuchen Sie dies mit einem Lambda-Ausdruck und org.Apache.commons.lang.StringUtils . Dadurch werden auch die null- und blank-Werte aus der array-Eingabe gelöscht

public static String[] cleanArray(String[] array) {
    return Arrays.stream(array).filter(x -> !StringUtils.isBlank(x)).toArray(String[]::new);
}

ref - https://stackoverflow.com/a/41935895/9696526

2
The Hunter

Zum Kommentar von Andrew Mairose - Obwohl dies eine gute Lösung ist, möchte ich nur hinzufügen, dass diese Lösung nicht funktionieren wird feste Größe Listen.

Sie könnten versuchen, dies so zu tun:

Arrays.asList(new String[]{"a", "b", null, "c", "    "})
    .removeIf(item -> item == null || "".equals(item));

Sie werden jedoch auf einen UnsupportedOperationException at Java.util.AbstractList.remove stoßen (da asList eine nicht skalierbare Liste zurückgibt). 

Eine andere Lösung könnte dies sein:

List<String> collect =
    Stream.of(new String[]{"a", "b", "c", null, ""})
        .filter(item -> item != null && !"".equals(item))
        .collect(Collectors.toList());

Was eine schöne Liste von Saiten ergibt :-)

1
Asaf Blum
   private List cleanInputs(String[] inputArray) {
        List<String> result = new ArrayList<String>(inputArray.length);
        for (String input : inputArray) {
            if (input != null) {
                String str = input.trim();
                if (!str.isEmpty()) {
                    result.add(str);
                }
            }
        }
        return result;
    }
0
user2982704