streamalism.org

1. Overzicht

In Groovy kunnen we net als in Java met lijsten werken. Maar met zijn ondersteuning voor uitbreidingsmethoden, wordt het geleverd met heel wat meer.

In deze tutorial kijken we naar Groovy's kijk op het muteren, filteren en sorteren van lijsten.

2. Groovy Lists maken

Groovy biedt bepaalde interessante snelkoppelingen bij het werken met verzamelingen die gebruik maken van de ondersteuning voor dynamisch typen en letterlijke syntaxis.

Laten we beginnen met het maken van een lijst met enkele waarden met behulp van de verkorte syntaxis:

def lijst = [1,2,3]

Evenzo kunnen we een lege lijst maken:

def emptyList = []

Groovy maakt standaard een instantie van java.util.ArrayList. Echter, we kunnen ook het type lijst specificeren dat moet worden gemaakt:

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

Vervolgens kunnen lijsten worden gebruikt om andere lijsten te maken met behulp van een constructorargument:

def copyList = nieuwe ArrayList (arrList)

of door te klonen:

def cloneList = arrList.clone ()

Merk op dat klonen een ondiepe kopie van de lijst creëert.

Groovy gebruikt de "==" operator om de elementen in twee lijsten te vergelijken voor gelijkheid. Verdergaand met het vorige voorbeeld, over vergelijken cloneList met lijst het resultaat is waar:

assertTrue (cloneList == arrList)

Laten we nu eens kijken hoe we enkele veelvoorkomende bewerkingen op lijsten kunnen uitvoeren.

3. Items ophalen uit een lijst

We kunnen een item uit een lijst halen met behulp van de letterlijke syntaxis, zoals:

def list = ["Hallo", "Wereld"] assertTrue (lijst [1] == "Wereld")

of met behulp van de krijgen() en getAt () methoden:

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

We kunnen ook items van een lijst krijgen met zowel positieve als negatieve indices. Bij gebruik van een negatieve index wordt de lijst van rechts naar links gelezen:

assertTrue (lijst [-1] == "Wereld") assertTrue (list.getAt (-2) == "Hallo")

Merk op dat de krijgen() methode ondersteunt geen negatieve indexen.

4. Items aan een lijst toevoegen

Er zijn meerdere verkorte manieren om items aan de lijst toe te voegen. Laten we een lege lijst definiëren en er een paar items aan toevoegen:

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

Vervolgens kunnen we ook de index specificeren om het item op te plaatsen. Ook, als de lengte van de lijst kleiner is dan de gespecificeerde index, dan voegt Groovy er zoveel toe nul waarden als het verschil:

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

Ten slotte kunnen we de "+=” operator om nieuwe items aan de lijst toe te voegen. Vergeleken met de andere benaderingen, deze operator maakt een nieuw lijstobject aan en wijst dit toe aan de variabele lijst:

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

5. Items in een lijst bijwerken

We kunnen items in een lijst bijwerken met behulp van de letterlijke syntaxis of de set () methode:

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

In dit voorbeeld worden de items op index 1 en 2 bijgewerkt met nieuwe waarden.

6. Items uit een lijst verwijderen

We kunnen een item op een bepaalde index verwijderen met de verwijderen() methode:

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

Of we kunnen ook een element verwijderen door de removeElement () methode. Dit verwijdert het eerste exemplaar van het element uit de lijst:

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

Bovendien, we kunnen de minus operator om alle exemplaren van een element uit de lijst te verwijderen. Deze operator muteert echter niet de onderliggende lijst - hij geeft een nieuwe lijst terug:

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

7. Itereren op een lijst

Groovy heeft nieuwe methoden toegevoegd aan de bestaande Java Collecties API. Deze methoden vereenvoudigen bewerkingen zoals filteren, zoeken, sorteren, aggregeren enz. Door de boilerplate-code in te kapselen. Ze ondersteunen ook een breed scala aan inputs, waaronder sluitingen en outputdatastructuren.

Laten we beginnen met het bekijken van de twee methoden voor het herhalen van een lijst.

De elk() methode accepteert een sluiting en lijkt sterk op de voor elk() methode in Java. Groovy geeft een impliciete parameter door het die overeenkomt met het huidige element in elke iteratie:

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

De andere methode, eachWithIndex () geeft de huidige indexwaarde naast het huidige element:

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

8. Filteren

Filteren is een andere bewerking die vaak op lijsten wordt uitgevoerd, en Groovy biedt veel verschillende methoden om uit te kiezen.

Laten we een lijst definiëren om mee te werken:

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

Om het eerste object te vinden dat overeenkomt met een voorwaarde, kunnen we gebruiken vind:

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

Om alle objecten te vinden die aan een conditie voldoen, kunnen we gebruiken vind alle:

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

Laten we naar een ander voorbeeld kijken. Hier willen we een lijst met alle elementen die getallen zijn:

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

Als alternatief kunnen we de grep methode om hetzelfde te doen:

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

Het verschil tussen grep en vind methoden is dat grep kan een Voorwerp of een Sluiting als argument. Het maakt het dus mogelijk om de voorwaarde-instructie verder terug te brengen tot het absolute minimum:

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

Bovendien, grep toepassingen Object # isCase (java.lang.Object) om de toestand op elk element van de lijst te evalueren.

Soms we zijn mogelijk alleen geïnteresseerd in de unieke items in een lijst. Er zijn twee overbelaste methoden die we hiervoor kunnen gebruiken.

De uniek() methode accepteert optioneel een afsluiting en behoudt in de onderliggende lijst alleen elementen die overeenkomen met de afsluitingsvoorwaarden, terwijl andere worden verwijderd. Het maakt standaard gebruik van natuurlijke ordening om het unieke karakter te bepalen:

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

Als alternatief, als de vereiste is om de onderliggende lijst niet te muteren, kunnen we de toUnique () methode:

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

Als we willen controleren of sommige of alle items in een lijst aan een bepaalde voorwaarde voldoen, kunnen we de elke () en ieder() methoden.

De elke () methode evalueert de voorwaarde in de sluiting voor elk element in de lijst. Daarna keert het alleen terug waar als alle elementen in de lijst voldoen aan de voorwaarde:

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

De ieder() methode, aan de andere kant, retourneert waar als een element in de lijst voldoet aan de voorwaarde:

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

9. Sorteren

Standaard sorteert Groovy de items in een lijst op basis van hun natuurlijke volgorde:

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

Maar we kunnen ook een Comparator met aangepaste sorteerlogica:

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

Bovendien kunnen we de min () of max () methoden om de maximum- of minimumwaarde te vinden zonder expliciet aan te roepen soort():

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. Verzamelen

Soms willen we de items in een lijst wijzigen en een andere lijst met bijgewerkte waarden retourneren. Dit kan gedaan worden met de verzamelen() methode:

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

11. Deelnemen

Soms moeten we de items in een lijst samenvoegen. Om dat te doen kunnen we de toetreden () methode:

assertTrue (["Een", "Twee", "Drie"]. join (",") == "Een, twee, drie")

12. Conclusie

In dit artikel hebben we enkele van de extensies behandeld die Groovy aan Java toevoegt Collecties API.

We zijn begonnen door naar de letterlijke syntaxis te kijken en vervolgens het gebruik ervan bij het maken, bijwerken, verwijderen en ophalen van items in een lijst.

Ten slotte keken we naar de ondersteuning van Groovy voor het herhalen, filteren, zoeken, verzamelen, samenvoegen en sorteren van lijsten.

Zoals altijd zijn alle voorbeelden die in het artikel worden besproken beschikbaar op GitHub.