Lister i Groovy

1. Oversigt

I Groovy kan vi arbejde med lister, ligesom vi gør i Java. Men med sin understøttelse af udvidelsesmetoder leveres den med en hel del mere.

I denne vejledning ser vi på Groovys påtagelse af mutations-, filtrerings- og sorteringslister.

2. Oprettelse af groovy lister

Groovy giver visse interessante genveje, når du arbejder med samlinger, der gør brug af dens understøttelse til dynamisk skrivning og bogstavelig syntaks.

Lad os begynde med at oprette en liste med nogle værdier ved hjælp af stenografi-syntaksen:

def liste = [1,2,3]

På samme måde kan vi oprette en tom liste:

def tomListe = []

Som standard opretter Groovy en forekomst af java.util.ArrayList. Imidlertid, Vi kan også specificere typen af ​​liste, der skal oprettes:

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

Derefter kan lister bruges til at oprette andre lister ved hjælp af et konstruktørargument:

def copyList = ny ArrayList (arrList)

eller ved kloning:

def cloneList = arrList.clone ()

Bemærk, at kloning opretter en lav kopi af listen.

Groovy bruger operatoren “==” til at sammenligne elementerne i to lister for lighed. Fortsætter med det foregående eksempel om sammenligning cloneList med arrlist resultatet er rigtigt:

assertTrue (cloneList == arrList)

Lad os nu se på, hvordan man udfører nogle almindelige operationer på lister.

3. Henter emner fra en liste

Vi kan få et element fra en liste ved hjælp af den bogstavelige syntaks, såsom:

def list = ["Hej", "Verden"] assertTrue (liste [1] == "Verden")

eller ved hjælp af få() og getAt () metoder:

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

Vi kan også få varer fra en liste ved hjælp af både positive og negative indekser. Når et negativt indeks bruges, læses listen fra højre mod venstre:

assertTrue (liste [-1] == "Verden") assertTrue (list.getAt (-2) == "Hej")

Bemærk, at få() metoden understøtter ikke negative indekser.

4. Tilføjelse af emner til en liste

Der er flere stenografiske måder til at tilføje varer til listen. Lad os definere en tom liste og tilføje et par emner til den:

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

Dernæst kan vi også specificere det indeks, som varen skal placeres på. Også, hvis længden på listen er mindre end det angivne indeks, tilføjer Groovy så mange nul værdier som forskellen:

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

Endelig kan vi bruge “+=” operatør for at tilføje nye emner til listen. Sammenlignet med de andre tilgange denne operatør opretter et nyt listeobjekt og tildeler det til variablen liste:

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

5. Opdatering af emner på en liste

Vi kan opdatere emner på en liste ved hjælp af den bogstavelige syntaks eller sæt() metode:

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

I dette eksempel opdateres elementerne i indeks 1 og 2 med nye værdier.

6. Fjernelse af emner fra en liste

Vi kan fjerne et element i et bestemt indeks ved hjælp af fjerne() metode:

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

Eller vi kan også fjerne et element ved hjælp af removeElement () metode. Dette fjerner den første forekomst af elementet fra listen:

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

Derudover vi kan bruge minus operatør for at fjerne alle forekomster af et element fra listen. Denne operatør muterer dog ikke den underliggende liste - den returnerer en ny liste:

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

7. Iterering på en liste

Groovy har tilføjet nye metoder til den eksisterende Java Samlinger API. Disse metoder forenkler operationer såsom filtrering, søgning, sortering, sammenlægning osv. Ved at indkapsle kedelpladekoden. De understøtter også en bred vifte af input, herunder lukninger og outputdatastrukturer.

Lad os starte med at se på de to metoder til iterering over en liste.

Det hver() metoden accepterer en lukning og ligner meget for hver() metode i Java. Groovy overfører en implicit parameter det der svarer til det aktuelle element i hver iteration:

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

Den anden metode, eachWithIndex () giver den aktuelle indeksværdi ud over det aktuelle element:

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

8. Filtrering

Filtrering er en anden operation, der ofte udføres på lister, og Groovy giver mange forskellige metoder at vælge imellem.

Lad os definere en liste til at operere på:

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

For at finde det første objekt, der matcher en betingelse, vi kan bruge finde:

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

For at finde alle objekter, der matcher en tilstand, vi kan bruge findAlle:

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

Lad os se på et andet eksempel. Her ønsker vi en liste over alle elementer, der er tal:

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

Alternativt kan vi bruge grep metode til at gøre det samme:

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

Forskellen på grep og finde metoder er det grep kan acceptere en Objekt eller a Lukning som et argument. Således tillader det yderligere at reducere betingelseserklæringen til det absolutte minimum:

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

Derudover grep anvendelser Objekt # isCase (java.lang.Object) at evaluere tilstanden på hvert element på listen.

Sommetider vi er måske kun interesseret i de unikke genstande på en liste. Der er to overbelastede metoder, som vi kan bruge til dette formål.

Det enestående() metode accepterer valgfrit en lukning og opbevarer kun i den underliggende liste elementer, der matcher lukningsbetingelserne, mens de kasserer andre. Den bruger naturlig ordning som standard til at bestemme unikhed:

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

Alternativt, hvis kravet ikke er at mutere den underliggende liste, kan vi bruge toUnique () metode:

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

Hvis vi vil kontrollere, at nogle eller alle elementerne på en liste opfylder en bestemt tilstand, kan vi bruge hver() og nogen() metoder.

Det hver() metode evaluerer tilstanden i lukningen mod hvert element på listen. Derefter vender den kun tilbage rigtigt hvis alle elementerne på listen opfylder betingelsen:

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

Det nogen() metode vender derimod tilbage rigtigt hvis et element på listen opfylder betingelsen:

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

9. Sortering

Som standard sorterer Groovy elementerne på en liste baseret på deres naturlige rækkefølge:

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

Men vi kan også passere en Komparator med brugerdefineret sorteringslogik:

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

Derudover kan vi bruge min () eller maks () metoder til at finde den maksimale eller minimale værdi uden eksplicit at ringe sortere():

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

10. Indsamling

Nogle gange vil vi måske ændre elementerne på en liste og returnere en anden liste med opdaterede værdier. Dette kan gøres ved hjælp af indsamle() metode:

def list = ["Kay", "Henry", "Justin", "Tom"] hævder sandt (list.collect {"Hej" + it} == ["Hej Kay", "Hej Henry", "Hej Justin", "Hej Tom"])

11. Tilslutning

Til tider kan det være nødvendigt at vi slutter os til elementerne på en liste. For at gøre det kan vi tilslutte() metode:

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

12. Konklusion

I denne artikel dækkede vi et par af de udvidelser, som Groovy tilføjer til Java Samlinger API.

Vi startede med at se på den bogstavelige syntaks og derefter brugen af ​​den til at oprette, opdatere, fjerne og hente emner i en liste.

Endelig kiggede vi på Groovys støtte til iterering, filtrering, søgning, indsamling, tilslutning og sortering af lister.

Som altid er alle eksemplerne, der er diskuteret i artiklen, tilgængelige på GitHub.