streamalism.org

1. Introduksjon

Groovy tilbyr et betydelig antall metoder som forbedrer Java's kjernefunksjoner.

I denne veiledningen viser vi hvordan Groovy gjør dette når å se etter et element og finne det i flere typer samlinger.

2. Test om elementet er til stede

Først vil vi fokusere på å bare teste om en gitt samling inneholder et element.

2.1. Liste

Java selv gir flere måter å se etter et element i en liste med java.util.Liste:

• De inneholder metode
• De oversikt over metode

Ettersom Groovy er et Java-kompatibelt språk, kan vi trygt bruke dem.

La oss ta en titt på et eksempel:

@Test ugyldig nårListContainsElement_thenCheckReturnsTrue () {def list = ['a', 'b', 'c'] assertTrue (list.indexOf ('a')> -1) assertTrue (list.contains ('a'))}

Bortsett fra det, Groovy introduserer medlemsoperatøren:

element i listen

Det er en av mange syntaktiske sukkeroperatører levert av Groovy. Med hjelpen kan vi forenkle koden vår:

@Test ugyldig nårListContainsElement_thenCheckWithMembershipOperatorReturnsTrue () {def list = ['a', 'b', 'c'] assertTrue ('a' i listen)}

2.2. Sett

Som med forrige eksempel, kan vi bruke java.util.Set # inneholder metoden og i operatør:

@Test ugyldig nårSetContainsElement_thenCheckReturnsTrue () {def set = ['a', 'b', 'c'] som Set assertTrue (set.contains ('a')) assertTrue ('a' i sett)}

2.3. Kart

I tilfelle av en Kart, kan vi se etter enten nøkkelen eller verdien direkte:

@Test ugyldig når MapContainsKeyElement_thenCheckReturnsTrue () {def map = [a: 'd', b: 'e', ​​c: 'f'] assertTrue (map.containsKey ('a')) assertFalse (map.containsKey ('e') ) assertTrue (map.containsValue ('e'))}

Eller bruk medlemsoperatør for å finne den matchende nøkkelen:

@Test ugyldig når MapContainsKeyElement_thenCheckByMembershipReturnsTrue () {def map = [a: 'd', b: 'e', ​​c: 'f'] assertTrue ('a' in map) assertFalse ('f' in map)}

Når det brukes med kart, bør vi bruke medlemsoperatøren med forsiktighet fordi denne operatøren er litt forvirrende å bruke med boolske verdier. I stedet for å teste for tilstedeværelsen av nøkkelen, henter den underliggende mekanismen den tilsvarende verdien fra kartet og rettferdig kaster den til boolsk:

@Test ugyldig når MapContainsFalseBooleanValues_thenCheckReturnsFalse () {def map = [a: true, b: false, c: null] assertTrue (map.containsKey ('b')) assertTrue ('a' in map) assertFalse ('b' in map) assertFalse ('c' på kartet)}

Som vi kan se i eksemplet ovenfor, er det også litt farlig å bruke med null verdier enten av samme grunn. Groovy kaster begge deler falsk og null til boolsk falsk.

3. All Match og hvilken som helst kamp

I de fleste tilfeller håndterer vi samlinger sammensatt av mer komplekse objekter. I denne delen viser vi hvordan du sjekker om den gitte samlingen inneholder minst ett matchende element, eller om alle elementene samsvarer med et gitt predikat.

La oss starte med å definere en enkel klasse som vi vil bruke gjennom eksemplene våre:

klasse Person {privat Streng fornavn privat Streng etternavn privat Heltall alder // konstruktør, getters og setter}

3.1. Liste / sett

Denne gangen bruker vi en enkel liste over Person gjenstander:

privat sluttpersonListe = [ny person ("Regina", "Fitzpatrick", 25), ny person ("Abagail", "Ballard", 26), ny person ("Lucian", "Walter", 30),]

Som vi nevnte før, Groovy er et Java-kompatibelt språk, så la oss først lage et eksempel ved hjelp av Strøm API introdusert av Java 8:

@Test ugyldig givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList () {assertTrue (personList.stream (). AnyMatch {it.age> 20}) assertFalse (personList.stream (). AllMatch {it.age <30})}

Vi kan også bruke Groovy-metodene DefaultGroovyMethods # any og DefaultGroovyMethods # hver som utfører sjekken direkte på samlingen:

@Test ugyldig givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList () {assertTrue (personList.any {it.age> 20}) assertFalse (personList.every {it.age <30})}

3.2. Kart

La oss starte med å definere en Kart av Person gjenstander kartlagt av Person # fornavn:

privat sluttpersonMap = [Regina: new Person ("Regina", "Fitzpatrick", 25), Abagail: new Person ("Abagail", "Ballard", 26), Lucian: new Person ("Lucian", "Walter", 30)]

Vi kan evaluere det ved hjelp av tastene, verdiene eller hele oppføringene. Igjen, la oss først bruke Strøm API:

@Test ugyldig givenMapOfPerson_whenUsingStreamMatching_thenShouldEvaluateMap () {assertTrue (personMap.keySet (). Stream (). AnyMatch {it == "Regina"}) assertFalse (personMap.keySet (). Stream (). AllMatch {it == "Albert ) assertFalse (personMap.values ​​(). stream (). allMatch {it.age <30}) assertTrue (personMap.entrySet (). stream (). anyMatch {it.key == "Abagail" && it.value.lastname == "Ballard"})}

Og deretter Groovy Collection API:

@Test ugyldig givenMapOfPerson_whenUsingCollectionMatching_thenShouldEvaluateMap () {assertTrue (personMap.keySet (). Any {it == "Regina"}) assertFalse (personMap.keySet (). Hver {it == "Albert"}) assertFalse (personM) .hver {it.age fornavn == "Abagail" && person.lastname == "Ballard"})}

Som vi ser, erstatter Groovy ikke bare tilstrekkelig Strøm API når vi manipulerer kart, men lar oss også utføre en sjekk direkte på Kart objekt i stedet for å bruke java.util.Map # entrySet metode.

4. Finn ett eller flere elementer i en samling

4.1. Liste / sett

Vi kan også trekke ut elementer ved hjelp av predikater. La oss starte med det kjente Strøm API-tilnærming:

@Test ugyldig givenListOfPerson_whenUsingStreamFind_thenShouldReturnMatchingElements () {assertTrue (personList.stream (). Filter {it.age> 20} .findAny (). IsPresent ()) assertFalse (personList.stream (). Filter {it.age> 30}. () .isPresent ()) assertTrue (personList.stream (). filter {it.age> 20} .findAll (). size () == 3) assertTrue (personList.stream (). filter {it.age> 30 } .findAll (). isEmpty ())}

Som vi kan se, bruker eksemplet ovenfor java.util. valgfritt for å finne et enkelt element som Strøm API tvinger den tilnærmingen.

På den annen side tilbyr Groovy en mye mer kompakt syntaks:

@Test ugyldig givenListOfPerson_whenUsingCollectionFind_thenShouldReturnMatchingElements () {assertNotNull (personList.find {it.age> 20}) assertNull (personList.find {it.age> 30}) assertTrue (personList.findAll {it.age> 20}. = 3) assertTrue (personList.findAll {it.age> 30} .isEmpty ())}

Ved å bruke Groovy's API, vi kan hoppe over å lage en Strøm og filtrere den.

4.2. Kart

I tilfelle av en Kart, det er flere alternativer å velge mellom. Vi kan finne elementer blant nøkler, verdier eller komplette oppføringer. Som de to første er i utgangspunktet en Liste eller a SettI denne delen viser vi bare et eksempel på å finne oppføringer.

La oss bruke vårt personMap fra tidligere:

@Test ugyldig givenMapOfPerson_whenUsingStreamFind_thenShouldReturnElements () {assertTrue (personMap.entrySet (). Stream () .filter {it.key == "Abagail" && it.value.lastname == "Ballard"} .findAny ().) Er Present assertTrue (personMap.entrySet (). stream () .filter {it.value.age> 20} .findAll (). størrelse () == 3)}

Og igjen, den forenklede Groovy-løsningen:

@Test ugyldig givenMapOfPerson_whenUsingCollectionFind_thenShouldReturnElements () {assertNotNull (personMap.find {it.key == "Abagail" && it.value.lastname == "Ballard"}) assertTrue (personMap.findAll {it.value.age> 20> () == 3)}

I dette tilfellet er fordelene enda mer betydningsfulle. Vi hopper over java.util.Map # entrySet metoden og bruk en lukking med en funksjon gitt på Kart.

5. Konklusjon

I denne artikkelen presenterte vi hvordan Groovy forenkler å sjekke etter elementer og finne dem i flere typer samlinger.

Som alltid er de komplette kodeeksemplene som brukes i denne opplæringen, tilgjengelige på GitHub.