streamalism.org

1. Prehľad

Groovy rozširuje Mapa API v Jave do poskytujú metódy pre operácie, ako je filtrovanie, vyhľadávanie a triedenie. Poskytuje tiež a rôzne stenografické spôsoby vytvárania a manipulácie s mapami.

V tomto článku sa pozrieme na Groovy spôsob práce s mapami.

2. Tvorba Groovy Mapas

Môžeme použiť syntax mapy [k: v] na vytváranie máp. V zásade nám umožňuje vytvoriť inštanciu mapy a definovať položky v jednom riadku.

Prázdnu mapu je možné vytvoriť pomocou:

def emptyMap = [:]

Podobne je možné vytvoriť inštanciu mapy s hodnotami pomocou:

def map = [meno: "Jerry", vek: 42 rokov, mesto: "New York"]

Všimni si klávesy nie sú obklopené úvodzovkami.

A predvolene Groovy vytvorí inštanciu java.util.LinkedHashMap. Toto predvolené správanie môžeme prepísať použitím ako operátor.

3. Pridávanie položiek

Začnime definovaním mapy:

def map = [meno: "Jerry"]

Na mapu môžeme pridať kľúč:

mapa ["age"] = 42

Ale ďalší spôsob podobný Javascriptu používa notáciu vlastností (bodkový operátor):

map.city = "New York"

Inými slovami, Groovy podporuje prístup k párom kľúč - hodnota fazuľovým spôsobom.

Pri pridávaní nových položiek do mapy môžeme ako kľúče použiť ako premenné aj premenné:

def hobbyLiteral = "hobby" def hobbyMap = [(hobbyLiteral): "Spievanie"] map.putAll (hobbyMap) assertTrue (hobbyMap.hobby == "Spievanie") assertTrue (hobbyMap [hobbyLiteral] == "Spev")

Najskôr musíme vytvoriť novú premennú, ktorá uloží kľúč koníček. Potom použijeme túto premennú uzavretú v zátvorkách so spisovou syntaxou mapy na vytvorenie ďalšej mapy.

4. Načítanie položiek

Na získanie položiek z mapy je možné použiť doslovnú syntax alebo zápis vlastnosti.

Pre mapu definovanú ako:

def map = [meno: "Jerry", vek: 42 rokov, mesto: "New York", hobby: "spev"]

Môžeme získať hodnotu zodpovedajúcu kľúču názov:

assertTrue (mapa ["name"] == "Jerry")

alebo

assertTrue (map.name == "Jerry")

5. Odstránenie položiek

Akýkoľvek záznam z mapy môžeme odstrániť pomocou kľúča pomocou odstrániť () metóda. Ale, niekedy bude možno potrebné z mapy odstrániť viac záznamov. To je možné vykonať pomocou mínus () metóda.

The mínus () metóda akceptuje a Mapa. A vráti nový Mapa po odstránení všetkých záznamov danej mapy z podkladovej mapy:

def mapa = [1:20, a: 30, 2:42, 4:34, ba: 67, 6:39, 7:49] def minusMap = mapa.minus ([2:42, 4:34]); assertTrue (minusMap == [1:20, a: 30, ba: 67, 6:39, 7:49])

Ďalej môžeme tiež odstrániť záznamy na základe podmienky. To sa dá dosiahnuť pomocou odobrať všetky() metóda:

minusMap.removeAll {it -> it.key instanceof String} assertTrue (minusMap == [1:20, 6:39, 7:49])

Naopak, na uchovanie všetkých záznamov, ktoré vyhovujú podmienke, môžeme použiť znak keepAll () metóda:

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

6. Iterácia cez záznamy

Položky môžeme iterovať pomocou každý ()a eachWithIndex () metódy.

The každý () metóda poskytuje implicitné parametre ako vstup, kľúča hodnotu ktoré zodpovedajú prúdu Vstup.

The eachWithIndex () metóda okrem indexu poskytuje aj index Vstup. Obe metódy akceptujú a Uzavretie ako argument.

V nasledujúcom príklade iterujeme každý z nich Vstup. The Uzavretie prešiel na každý () metóda získa pár kľúč - hodnota zo záznamu implicitného parametra a vytlačí ho:

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

Ďalej použijeme eachWithIndex () metóda pre tlač aktuálneho indexu spolu s ďalšími hodnotami:

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

Je tiež možné požiadať kľúč, hodnota, a index sa dodávajú osobitne:

map.eachWithIndex {kľúč, hodnota, i -> println "$ i $ kľúč: $ hodnota"}

7. Filtrovanie

Môžeme použiť find (), findAll () a grep () metódy filtrovania a vyhľadávania záznamov na mape na základe kľúčov a hodnôt.

Začnime definovaním mapy, na ktorej sa budú vykonávať tieto metódy:

def map = [meno: "Jerry", vek: 42 rokov, mesto: "New York", hobby: "spev"]

Najprv sa pozrieme na Nájsť() metóda, ktorá akceptuje a Uzavretie a vráti prvý Vstup ktorý sa zhoduje s Uzavretie stav:

assertTrue (map.find {it.value == "New York"}. key == "city")

Podobne findAll prijíma aj a Uzavretie ale vracia a Mapa so všetkými pármi kľúč - hodnota, ktoré vyhovujú podmienke v Uzavretie:

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

Ak by sme radšej používali Zoznam, môžeme však použiť grep namiesto findAll:

map.grep {it.value == "New York"}. každý {it -> assertTrue (it.key == "city" && it.value == "New York")}

Najprv sme použili grep na nájdenie záznamov, ktoré majú hodnotu ako New York. Potom na preukázanie návratového typu je Zoznam, iterujeme výsledkom grep (). A za každú Vstup v zozname, ktorý je k dispozícii v implicitnom parametri, skontrolujeme, či je jeho očakávaným výsledkom.

Ďalej môžeme zistiť, či všetky položky na mape spĺňajú podmienku každý ktorý vracia a boolovský.

Poďme skontrolovať, či sú všetky hodnoty na mape typové String:

assertTrue (map.every {it -> it.value instanceof String} == false)

Podobne môžeme použiť akýkoľvek na určenie, či niektoré položky na mape zodpovedajú podmienke:

assertTrue (map.any {it -> it.value instanceof String} == true)

8. Transformácia a zhromažďovanie

Občas možno budeme chcieť transformovať položky na mape na nové hodnoty. Pomocou zbierať () a collectEntries () metód je možné transformovať a zbierať záznamy do a Zbierka alebo Mapa resp.

Pozrime sa na niekoľko príkladov.

Vzhľadom na mapu ID zamestnancov a zamestnancov:

def map = [1: [meno: „Jerry“, vek: 42 rokov, mesto: „New York“], 2: [meno: „Long“, vek: 25 rokov, mesto: „New York“], 3: [meno : „Dustin“, vek: 29 rokov, mesto: „New York“], 4: [meno: „Dustin“, vek: 34 rokov, mesto: „New York“]]

Mená všetkých zamestnancov môžeme zhromaždiť do zoznamu pomocou zbierať ():

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

Ďalej, ak nás zaujíma jedinečná množina mien, môžeme určiť kolekciu zadaním a Zbierka objekt:

def uniqueNames = map.collect ([] ako HashSet) {entry -> entry.value.name} assertTrue (uniqueNames == ["Jerry", "Long", "Dustin"] ako nastavený)

Ak chceme zmeniť mená zamestnancov na mape z malých na veľké, môžeme použiť collectEntries. Táto metóda vráti mapu transformovaných hodnôt:

def idNames = map.collectEntries {kľúč, hodnota -> [kľúč, hodnota.názov]} assertTrue (idNames == [1: "Jerry", 2: "Long", 3: "Dustin", 4: "Dustin"] )

Nakoniec je tiež možné použiť zbierať metódy v spojení s Nájsť a findAll metódy transformovať filtrované výsledky:

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

Tu najskôr nájdeme všetkých zamestnancov vo veku od 20 do 30 rokov a zhromaždíme ich do mapy.

9. Zoskupenie

Niekedy možno budeme chcieť zoskupiť niektoré položky mapy do submapov na základe podmienky.

The groupBy () metóda vráti mapu máp. A každá mapa obsahuje páry kľúč - hodnota, ktoré sa za danej podmienky vyhodnotia s rovnakým výsledkom:

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

Ďalším spôsobom vytvárania submap je použitie subMap (). Iné je to v groupBy () v tom zmysle, že umožňuje iba zoskupenie na základe kľúčov:

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

V takom prípade sa položky pre kľúče 1 a 2 vrátia na novú mapu a všetky ostatné položky sa zahodia.

10. Triedenie

Zvyčajne pri triedení môžeme chcieť zoradiť položky na mape podľa kľúča, hodnoty alebo oboch. Groovy poskytuje a sort () metóda, ktorá sa môže na tento účel použiť.

Daná mapa:

def mapa = [ab: 20, a: 40, cb: 11, ba: 93]

Ak je potrebné triedenie na kľúči, použite no-args sort () metóda, ktorá je založená na prirodzenom usporiadaní:

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

Alebo použite triediť (komparátor) metóda poskytujúca logiku porovnania:

def compSortedMap = map.sort ({k1, k2 -> k1 k2} ako komparátor) assertTrue ([a: 40, ab: 20, ba: 93, cb: 11] == compSortedMap)

Ďalšie, na triedenie podľa kľúča alebo hodnôt alebo oboch môžeme dodať a Uzavretie stav do sort ():

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

11. Záver

Začali sme tým, že sme sa pozreli na to, ako môžeme tvoriť Mapas v Groovy. Ďalej sme sa pozreli na rôzne spôsoby, ako je možné pridávať, načítať a odstraňovať položky z mapy.

Neskôr sme sa zaoberali metódami na vykonávanie bežných operácií, ktoré sa poskytujú priamo z krabice v aplikácii Groovy. Zahŕňali filtrovanie, vyhľadávanie, transformáciu a triedenie.

Príklady uvedené v článku nájdete ako vždy na GitHub.