Listen in Groovy

1. Übersicht

In Groovy können wir mit Listen genauso arbeiten wie in Java. Mit seiner Unterstützung für Erweiterungsmethoden wird es jedoch mit viel mehr ausgeliefert.

In diesem Tutorial sehen wir uns Groovys Ansatz zum Mutieren, Filtern und Sortieren von Listen an.

2. Erstellen von Groovy-Listen

Groovy bietet bei der Arbeit mit Sammlungen einige interessante Verknüpfungen, die die Unterstützung für dynamische Typisierung und wörtliche Syntax nutzen.

Beginnen wir mit der Erstellung einer Liste mit einigen Werten unter Verwendung der Kurzsyntax:

def list = [1,2,3]

Ebenso können wir eine leere Liste erstellen:

def emptyList = []

Standardmäßig erstellt Groovy eine Instanz von java.util.ArrayList. Allerdings können wir auch die Art der Liste angeben zu erstellen :

def linkedList = [1,2,3] as LinkedList ArrayList arrList = [1,2,3]

Als nächstes können Listen verwendet werden, um andere Listen mithilfe eines Konstruktorarguments zu erstellen:

def copyList = new ArrayList(arrList)

oder durch Klonen:

def cloneList = arrList.clone()

Beachten Sie, dass beim Klonen eine flache Kopie der Liste erstellt wird.

Groovy verwendet den Operator "==", um die Elemente in zwei Listen auf Gleichheit zu vergleichen. Wenn Sie mit dem vorherigen Beispiel fortfahren und cloneList mit arrlist vergleichen, ist das Ergebnis wahr:

assertTrue(cloneList == arrList)

Schauen wir uns nun an, wie einige allgemeine Vorgänge für Listen ausgeführt werden.

3. Elemente aus einer Liste abrufen

Wir können ein Element aus einer Liste mithilfe der Literal-Syntax abrufen, z. B.:

def list = ["Hello", "World"] assertTrue(list[1] == "World")

oder mit den Methoden get () und getAt () :

assertTrue(list.get(1) == "World") assertTrue(list.getAt(1) == "World")

Wir können auch Elemente aus einer Liste mit positiven und negativen Indizes abrufen. Wenn ein negativer Index verwendet wird, wird die Liste von rechts nach links gelesen:

assertTrue(list[-1] == "World") assertTrue(list.getAt(-2) == "Hello")

Beachten Sie, dass die Methode get () keine negativen Indizes unterstützt.

4. Hinzufügen von Elementen zu einer Liste

Es gibt mehrere Kurzformen zum Hinzufügen von Elementen zur Liste. Definieren wir eine leere Liste und fügen ein paar Elemente hinzu:

def list = [] list << 1 list.add("Apple") assertTrue(list == [1, "Apple"])

Als nächstes können wir auch den Index angeben, an dem das Element platziert werden soll. Auch wenn die Länge der Liste ist kleiner als der Index angegeben, dann Groovy fügt so viele Nullwerte als Differenz :

list[2] = "Box" list[4] = true assertTrue(list == [1, "Apple", "Box", null, true])

Zuletzt können wir den Operator " + =" verwenden , um der Liste neue Elemente hinzuzufügen. Im Vergleich zu den anderen Ansätzen schafft dieser Operator eine neue Liste Objekt und weist ihn der Variablen Liste :

def list2 = [1,2] list += list2 list += 12 assertTrue(list == [1, 6.0, "Apple", "Box", null, true, 1, 2, 12])

5. Aktualisieren von Elementen in einer Liste

Wir können Elemente in einer Liste mithilfe der Literal-Syntax oder der set () -Methode aktualisieren :

def list =[1, "Apple", 80, "App"] list[1] = "Box" list.set(2,90) assertTrue(list == [1, "Box", 90, "App"])

In diesem Beispiel werden die Elemente in Index 1 und 2 mit neuen Werten aktualisiert.

6. Elemente aus einer Liste entfernen

Wir können ein Element an einem bestimmten Index mit der Methode remove () entfernen :

def list = [1,2,3,4,5,5,6,6,7] list.remove(3) assertTrue(list == [1,2,3,5,5,6,6,7])

Oder wir können ein Element auch mithilfe der removeElement () -Methode entfernen . Dadurch wird das erste Vorkommen des Elements aus der Liste entfernt:

list.removeElement(5) assertTrue(list == [1,2,3,5,6,6,7])

Zusätzlich können wir den Minus- Operator verwenden, um alle Vorkommen eines Elements aus der Liste zu entfernen . Dieser Operator mutiert jedoch nicht die zugrunde liegende Liste - er gibt eine neue Liste zurück:

assertTrue(list - 6 == [1,2,3,5,7])

7. Iterieren auf einer Liste

Groovy hat der vorhandenen Java Collections- API neue Methoden hinzugefügt . Diese Methoden vereinfachen Vorgänge wie Filtern, Suchen, Sortieren, Aggregieren usw. durch Einkapseln des Boilerplate-Codes. Außerdem unterstützen sie eine Vielzahl von Eingaben, einschließlich Schließungen und Ausgabedatenstrukturen.

Betrachten wir zunächst die beiden Methoden zum Durchlaufen einer Liste.

Die Methode each () akzeptiert einen Abschluss und ist der Methode foreach () in Java sehr ähnlich . Groovy übergibt einen impliziten Parameter , der dem aktuellen Element in jeder Iteration entspricht:

def list = [1,"App",3,4] list.each {println it * 2}

Die andere Methode, eachWithIndex (), liefert zusätzlich zum aktuellen Element den aktuellen Indexwert:

list.eachWithIndex{ it, i -> println "$i : $it" }

8. Filtern

Das Filtern ist eine weitere Operation, die häufig für Listen ausgeführt wird, und Groovy bietet viele verschiedene Methoden zur Auswahl.

Definieren wir eine Liste für die Bearbeitung:

def filterList = [2,1,3,4,5,6,76]

Um das erste Objekt zu finden, das einer Bedingung entspricht, können wir find verwenden :

assertTrue(filterList.find {it > 3} == 4)

Um alle Objekte zu finden, die einer Bedingung entsprechen, können wir findAll verwenden :

assertTrue(filterList.findAll {it > 3} == [4,5,6,76])

Schauen wir uns ein anderes Beispiel an. Hier wollen wir eine Liste aller Elemente, die Zahlen sind:

assertTrue(filterList.findAll {it instanceof Number} == [2,1,3,4,5,6,76])

Alternativ können wir die grep- Methode verwenden, um dasselbe zu tun:

assertTrue(filterList.grep( Number ) == [2,1,3,4,5,6,76])

Der Unterschied zwischen grep- und find- Methoden besteht darin, dass grep ein Objekt oder einen Abschluss als Argument akzeptieren kann . Auf diese Weise kann die Bedingungsanweisung weiter auf das Nötigste reduziert werden:

assertTrue(filterList.grep {it > 6} == [76])

Darüber hinaus verwendet grep Object # isCase (java.lang.Object) , um die Bedingung für jedes Element der Liste auszuwerten.

Manchmal interessieren uns nur die einzelnen Elemente in einer Liste . Es gibt zwei überladene Methoden, die wir für diesen Zweck verwenden können.

Die Methode unique () akzeptiert optional einen Abschluss und behält in der zugrunde liegenden Liste nur Elemente bei, die den Abschlussbedingungen entsprechen, während andere verworfen werden. Standardmäßig wird die natürliche Reihenfolge verwendet, um die Eindeutigkeit zu bestimmen:

def uniqueList = [1,3,3,4] uniqueList.unique() assertTrue(uniqueList == [1,3,4])

Wenn die Anforderung nicht darin besteht, die zugrunde liegende Liste zu mutieren, können Sie alternativ die Methode toUnique () verwenden:

assertTrue(["A", "B", "Ba", "Bat", "Cat"].toUnique {it.size()} == ["A", "Ba", "Bat"])

Wenn wir überprüfen möchten, ob einige oder alle Elemente in einer Liste eine bestimmte Bedingung erfüllen, können wir die Methoden every () und any () verwenden.

Die Methode every () wertet die Bedingung im Abschluss für jedes Element in der Liste aus. Dann wird nur dann true zurückgegeben, wenn alle Elemente in der Liste die Bedingung erfüllen:

def conditionList = [2,1,3,4,5,6,76] assertFalse(conditionList.every {it < 6})

Die any () -Methode gibt andererseits true zurück , wenn ein Element in der Liste die Bedingung erfüllt:

assertTrue(conditionList.any {it % 2 == 0})

9. Sortieren

Standardmäßig sortiert Groovy die Elemente in einer Liste nach ihrer natürlichen Reihenfolge:

assertTrue([1,2,1,0].sort() == [0,1,1,2])

Aber wir können auch einen Pass Vergleicher mit benutzerdefinierter Sortierlogik :

Comparator mc = {a,b -> a == b? 0: a < b? 1 : -1} def list = [1,2,1,0] list.sort(mc) assertTrue(list == [2,1,1,0])

Zusätzlich können wir die Methoden min () oder max () verwenden, um den Maximal- oder Minimalwert zu ermitteln, ohne sort () explizit aufzurufen :

def strList = ["na", "ppp", "as"] assertTrue(strList.max() == "ppp")
Comparator minc = {a,b -> a == b? 0: a < b? -1 : 1} def numberList = [3, 2, 0, 7] assertTrue(numberList.min(minc) == 0)

10. Sammeln

Manchmal möchten wir möglicherweise die Elemente in einer Liste ändern und eine andere Liste mit aktualisierten Werten zurückgeben. Dies kann mit der Methode collect () erfolgen :

def list = ["Kay","Henry","Justin","Tom"] assertTrue(list.collect{"Hi " + it} == ["Hi Kay","Hi Henry","Hi Justin","Hi Tom"])

11. Beitreten

Manchmal müssen wir die Elemente in einer Liste zusammenfügen. Dazu können wir die join () -Methode verwenden:

assertTrue(["One","Two","Three"].join(",") == "One,Two,Three")

12. Schlussfolgerung

In diesem Artikel haben wir einige der Erweiterungen behandelt, die Groovy zur Java Collections- API hinzufügt .

Wir haben uns zunächst die Literal-Syntax und ihre Verwendung beim Erstellen, Aktualisieren, Entfernen und Abrufen von Elementen in einer Liste angesehen.

Schließlich haben wir uns die Unterstützung von Groovy für das Iterieren, Filtern, Suchen, Sammeln, Verbinden und Sortieren von Listen angesehen.

Wie immer sind alle im Artikel diskutierten Beispiele auf GitHub verfügbar.