Térképek Groovy-ban

1. Áttekintés

Groovy kiterjeszti a Térkép API Java-ban biztosítson módszereket olyan műveletekhez, mint a szűrés, keresés és rendezés. Azt is biztosítja, hogy a a térképek készítésének és manipulálásának különféle gyorsírási módjai.

Ebben a cikkben megvizsgáljuk a térképekkel való Groovy-módszert.

2. Groovy létrehozása Térképs

Használhatjuk a térkép szó szerinti szintaxisát [k: v] térképek készítéséhez. Alapvetően lehetővé teszi számunkra a térkép példányosítását és a bejegyzések egy sorban történő meghatározását.

Üres térkép készíthető a következők használatával:

def emptyMap = [:]

Hasonlóképpen, az értékekkel ellátott térkép példányosítható:

def térkép = [név: "Jerry", életkor: 42, város: "New York"]

Figyelje meg a kulcsokat nem veszik körül idézőjelek.

És alapértelmezés szerint Groovy létrehozza a java.util.LinkedHashMap. Ezt az alapértelmezett viselkedést felülírhatjuk a mint operátor.

3. Tételek hozzáadása

Kezdjük egy térkép definiálásával:

def térkép = [név: "Jerry"]

Hozzáadhatunk egy kulcsot a térképhez:

térkép ["kor"] = 42

De egy másik, Javascript-szerűbb módszer a tulajdonságjelölés (a dot operátor) használata:

map.city = "New York"

Más szavakkal, Groovy támogatja a kulcs-érték párok babhoz hasonló megközelítését.

Változókat is használhatunk literálok helyett kulcsként, miközben új elemeket adunk a térképhez:

def hobbyLiteral = "hobby" def hobbyMap = [(hobbyLiteral): "Éneklés"] map.putAll (hobbyMap) assertTrue (hobbyMap.hobby == "Éneklés") assertTrue (hobbyMap [hobbyLiteral] == "Éneklés")

Először létre kell hoznunk egy új változót, amely tárolja a kulcsot hobbi. Ezután ezt a zárójelbe zárt változót használjuk a térkép szó szerinti szintaxisával egy másik térkép létrehozásához.

4. Elemek lekérése

A szó szerinti szintaxist vagy a tulajdonságjelölést használhatja elemek lekérésére a térképről.

A következőképpen definiált térkép esetében:

def map = [név: "Jerry", életkor: 42, város: "New York", hobbi: "ének"]

Megkaphatjuk a kulcsnak megfelelő értéket név:

assertTrue (térkép ["név"] == "Jerry")

vagy

assertTrue (térkép.név == "Jerry")

5. Tételek eltávolítása

Bármely bejegyzést eltávolíthatunk a térképről egy kulcs alapján a eltávolítás () módszer. De, néha előfordulhat, hogy több bejegyzést is el kell távolítanunk egy térképről. Ez a mínusz() módszer.

A mínusz() módszer elfogadja a Térkép. És visszaad egy újat Térkép miután eltávolította az adott térkép összes bejegyzését az alapul szolgáló térképről:

def térkép = [1:20, a: 30, 2:42, 4:34, ba: 67, 6:39, 7:49] def mínuszMap = map.minusz ([2:42, 4:34]); assertTrue (mínuszTérkép == [1:20, a: 30, ba: 67, 6:39, 7:49])

Ezután egy feltétel alapján is eltávolíthatjuk a bejegyzéseket. Ez a összes eltávolítása() módszer:

minusMap.removeAll {it -> it.key stringof string} assertTrue (mínuszMap == [1:20, 6:39, 7:49])

Fordítva, az összes bejegyzés megtartásához, amely teljesít egy feltételt, használhatjuk a retainAll () módszer:

minusMap.retainAll {it -> it.value% 2 == 0} assertTrue (mínuszMap == [1:20])

6. Iterálás a bejegyzések révén

A bejegyzés segítségével iterálhatunk a minden egyes()és eachWithIndex () mód.

A minden egyes() módszer olyan implicit paramétereket nyújt, mint a belépés, kulcs, és érték amelyek megfelelnek az áramnak Belépés.

A eachWithIndex () módszer mellett indexet is nyújt Belépés. Mindkét módszer elfogadja a Bezárás érvként.

A következő példában mindegyiket végig iteráljuk Belépés. A Bezárás átadta a minden egyes() A metódus megkapja a kulcs-érték párot az implicit paraméterbejegyzésből, és kinyomtatja:

map.each {entry -> println "$ entry.key: $ entry.value"}

Ezután a eachWithIndex () módszer az aktuális index kinyomtatására más értékekkel együtt:

map.eachWithIndex {bejegyzés, i -> println "$ i $ entry.key: $ entry.value"}

Meg lehet kérdezni a kulcs, érték, és az indexet külön kell szállítani:

map.eachWithIndex {kulcs, érték, i -> println "$ i $ kulcs: $ érték"}

7. Szűrés

Használhatjuk a find (), findAll () és grep () módszerek a térképbejegyzések szűrésére és keresésére kulcsok és értékek alapján.

Kezdjük azzal, hogy definiálunk egy térképet a következő módszerek végrehajtására:

def map = [név: "Jerry", életkor: 42, város: "New York", hobbi: "ének"]

Először megnézzük a megtalálja() módszer, amely elfogadja a Bezárás és visszaadja az elsőt Belépés hogy megfelel a Bezárás feltétel:

assertTrue (map.find {it.value == "New York"}. kulcs == "város")

Hasonlóképpen, Találd meg mindet is elfogadja a Bezárás de visszaadja a Térkép az összes olyan kulcsérték-párral, amely kielégíti a Bezárás:

assertTrue (map.findAll {it.value == "New York"} == [város: "New York"])

Ha inkább a Lista, bár használhatjuk grep ahelyett Találd meg mindet:

map.grep {it.value == "New York"}. mindegyik {it -> assertTrue (it.key == "város" && it.value == "New York")}

Először a grep segítségével kerestük meg azokat a bejegyzéseket, amelyek értéke New York. Ezután a visszatérési típus bemutatásához Lista, eredménye alapján iterálunk grep (). És mindegyikre Belépés az implicit paraméterben elérhető listában ellenőrizzük, hogy a várt eredmény-e.

Ezután annak kiderítése, hogy a térkép összes eleme megfelel-e egy feltételnek, amelyet felhasználhatunk minden amely visszaadja a logikai.

Ellenőrizzük, hogy a térkép összes értéke típus-e Húr:

assertTrue (map.every {it -> it.value stringof string} == hamis)

Hasonlóképpen használhatjuk Bármi annak megállapítása, hogy a térkép bármely eleme megfelel-e egy feltételnek:

assertTrue (map.any {it -> it.value stringof string} == true)

8. Átalakítás és gyűjtés

Időnként érdemes a térkép bejegyzéseit új értékekké alakítani. Használni a gyűjt() és collectEntries () módszerekkel lehetséges a bejegyzések átalakítása és gyűjtése a Gyűjtemény vagy Térkép illetőleg.

Nézzünk meg néhány példát.

Adott egy alkalmazotti azonosító és alkalmazottak térképe:

def térkép = [1: [név: "Jerry", életkor: 42, város: "New York"], 2: [név: "Hosszú", életkor: 25, város: "New York"], 3: [név : "Dustin", életkor: 29, város: "New York"], 4: [név: "Dustin", életkor: 34, város: "New York"]]

Az összes alkalmazott nevét egy listába gyűjthetjük a használatával gyűjt():

def nevek = map.collect {entry -> entry.value.name} assertTrue (names == ["Jerry", "Long", "Dustin", "Dustin"])

Ezután, ha egyedi névkészlet érdekel, akkor megadhatjuk a gyűjteményt az a áthaladásával Gyűjtemény tárgy:

def egyediNevek = map.collect ([] mint HashSet) {entry -> entry.value.name} assertTrue (egyediNév == ["Jerry", "Long", "Dustin"] mint Set)

Ha a térképen lévő alkalmazottak nevét kisbetűkről nagybetűkre akarjuk változtatni, használhatjuk collectEntries. Ez a módszer az átalakított értékek térképét adja vissza:

def idNames = map.collectEntries {kulcs, érték -> [kulcs, érték.név]} assertTrue (idNames == [1: "Jerry", 2: "Hosszú", 3: "Dustin", 4: "Dustin"] )

Végül, az is használható gyűjt módszerekkel együtt a megtalálja és Találd meg mindet mód a szűrt eredmények átalakításához:

def below30Names = map.findAll {it.value.age value.name} assertTrue (alle30Names == ["Hosszú", "Dustin"])

Itt találunk először minden 20-30 év közötti alkalmazottat, és összegyűjtjük őket egy térképre.

9. Csoportosítás

Előfordulhat, hogy a térkép egyes elemeit feltétel alapján szeretnénk résztérképekbe csoportosítani.

A csoportosít() A metódus a térképek térképét adja vissza. És minden térkép tartalmaz kulcs-érték párokat, amelyek ugyanazon eredményt értékelik az adott feltétel esetében:

def map = [1:20, 2: 40, 3: 11, 4: 93] def subMap = map.groupBy {it.value% 2} assertTrue (subMap == [0: [1:20, 2:40] , 1: [3:11, 4:93]])

Az altérképek létrehozásának másik módja a subMap (). Ez más csoportosít() abban az értelemben, hogy csak a kulcsok alapján engedélyezi a csoportosítást:

def keySubMap = map.subMap ([1,2]) assertTrue (keySubMap == [1:20, 2:40])

Ebben az esetben az 1. és 2. kulcs bejegyzései visszatérnek az új térképre, és az összes többi bejegyzés elvetésre kerül.

10. Rendezés

Rendezéskor általában a térkép bejegyzéseit érdemes kulcs vagy érték vagy mindkettő alapján rendezni. Groovy biztosítja a fajta() módszer, amelyet erre a célra lehet használni.

Adott térkép:

def térkép = [ab: 20, a: 40, cb: 11, ba: 93]

Ha kulcson kell rendezni, használja a no-args parancsot fajta() a természetes rendezésen alapuló módszer:

def természetesenOrderedMap = map.sort () assertTrue ([a: 40, ab: 20, ba: 93, cb: 11] == természetesenOrderedMap)

Vagy használja a rendezés (összehasonlító) módszer az összehasonlítási logika biztosítására:

def compSortedMap = map.sort ({k1, k2 -> k1 k2} mint összehasonlító) assertTrue ([a: 40, ab: 20, ba: 93, cb: 11] == compSortedMap)

Következő, vagy kulcs vagy érték, vagy mindkettő rendezéséhez megadhatjuk a Bezárás feltétele annak fajta():

def cloSortedMap = map.sort ({it1, it2 -> it1.value it1.value}) assertTrue ([cb: 11, ab: 20, a: 40, ba: 93] == cloSortedMap)

11. Következtetés

Azzal kezdtük, hogy megvizsgáltuk, hogyan tudunk alkotni Térképs Groovy-ban. Ezután megvizsgáltuk, hogyan lehet elemeket hozzáadni, visszakeresni és eltávolítani a térképről.

Később áttekintettük a közös műveletek végrehajtásának módszereit, amelyeket Groovy-n kívülről biztosítunk. Tartalmazta a szűrést, a keresést, az átalakítást és a válogatást.

Mint mindig, a cikkben szereplő példák megtalálhatók a GitHub-on.