Oversikt over Kotlin Collections API
1. Oversikt
I denne raske opplæringen vil vi introdusere Kotlins Collections API, og vi vil diskutere de forskjellige samlingstypene i Kotlin og noen vanlige operasjoner på samlinger.
2. Samling vs Muterbar samling
La oss først se på forskjellige typer samlinger i Kotlin. Vi vil se hvordan vi kan initialisere de grunnleggende typer samlinger.
De Samling grensesnittet støtter skrivebeskyttede metoder mens MutableCollection støtte lese / skrive metoder.
2.1. Liste
Vi kan lage en enkel skrivebeskyttet Liste ved hjelp av metode liste over() og lese-skrive MutableList ved hjelp av mutableListOf ():
val theList = listOf ("one", "two", "three") val theMutableList = mutableListOf ("one", "two", "three")
2.2. Sett
På samme måte kan vi lage en skrivebeskyttet Sett ved hjelp av metode setOf () og lese-skrive MutableSet ved hjelp av mutableSetOf ():
val theSet = setOf ("one", "two", "three") val theMutableSet = mutableSetOf ("one", "two", "three")
2.3. Kart
Vi kan også lage en skrivebeskyttet Kart ved hjelp av metode mapOf () og lese-skrive MutableMap ved hjelp av mutableMapOf ():
val theMap = mapOf (1 til "en", 2 til "to", 3 til "tre") val theMutableMap = mutableMapOf (1 til "en", 2 til "to", 3 til "tre")
3. Nyttige operatører
Kotlins Collections API er mye rikere enn den vi kan finne i Java - den kommer med et sett med overbelastede operatører.
3.1. “i" Operatør
Vi kan bruke uttrykk “x i samlingen”Som kan oversettes til collection.contains (x):
@Test moro nårSearchForExistingItem_thenFound () {val theList = listOf ("one", "two", "three") assertTrue ("two" in theList)}
3.2. De “+” Operatør
Vi kan et element eller en hel samling til en annen ved hjelp av "+" -operatøren:
@Test moro nårJoinTwoCollections_thenSuccess () {val firstList = listOf ("one", "two", "three") val secondList = listOf ("four", "five", "six") val resultList = firstList + secondList assertEquals (6 , resultList.size) assertTrue (resultList.contains ("two")) assertTrue (resultList.contains ("five"))}
3.3. De “-“ Operatør
På samme måte kan vi fjerne et element eller flere elementer ved hjelp av "-" operator:
@Test moro nårExcludeItems_thenRemoved () {val firstList = listOf ("one", "two", "three") val secondList = listOf ("one", "three") val resultList = firstList - secondList assertEquals (1, resultList.size ) assertTrue (resultList.contains ("two"))}
4. Andre metoder
Til slutt vil vi utforske noen vanlige metoder for innsamling. I Java, hvis vi ønsket å utnytte avanserte metoder, måtte vi bruke Strøm API.
I Kotlin kan vi finne lignende metoder som er tilgjengelige i Collections API.
4.1. Skjæring
Vi kan få en underliste fra en gitt Liste:
@Test moro nårSliceCollection_thenSuccess () {val theList = listOf ("one", "two", "three") val resultList = theList.slice (1..2) assertEquals (2, resultList.size) assertTrue (resultList.contains ( "to"))}
4.2. Fjerner
Vi kan enkelt fjerne alle null fra a Liste:
@Test moro nårFilterNullValues_thenSuccess () {val theList = listOf ("one", null, "two", null, "three") val resultList = theList.filterNotNull () assertEquals (3, resultList.size)}
4.3. Filtrering
Vi kan filtrere samleelementer enkelt ved hjelp av filter(), som fungerer på samme måte som filter() metode fra Java Strøm API:
@Test fun whenFilterNonPositiveValues_thenSuccess () {val theList = listOf (1, 2, -3, -4, 5, -6) val resultList = theList.filter {it> 0} assertEquals (3, resultList.size) assertTrue (resultList. inneholder (1)) assertFalse (resultList.contains (-4))}
4.4. Dropper
Vi kan droppe de første N-elementene:
@Test moro nårDropFirstItems_thenRemoved () {val theList = listOf ("one", "two", "three", "four") val resultList = theList.drop (2) assertEquals (2, resultList.size) assertFalse (resultList.contains ("en")) assertFalse (resultList.contains ("to"))}
Vi kan slippe de første elementene hvis de tilfredsstiller den gitte betingelsen:
@Test moro nårDropFirstItemsBasedOnCondition_thenRemoved () {val theList = listOf ("one", "two", "three", "four") val resultList = theList.dropWhile {it.length <4} assertEquals (2, resultList.size) assertFalse (resultList.contains ("one")) assertFalse (resultList.contains ("two"))}
4.5. Gruppering
Vi kan gruppere elementer:
@Test fun whenGroupItems_thenSuccess () {val theList = listOf (1, 2, 3, 4, 5, 6) val resultMap = theList.groupBy {it% 3} assertEquals (3, resultMap.size) assertTrue (resultMap [1]! ! .contains (1)) assertTrue (resultMap [2] !!. inneholder (5))}
4.6. Kartlegging
Vi kan kartlegge alle elementene ved hjelp av den medfølgende funksjonen:
@Test fun whenApplyFunctionToAllItems_thenSuccess () {val theList = listOf (1, 2, 3, 4, 5, 6) val resultList = theList.map {it * it} assertEquals (4, resultList [1]) assertEquals (9, resultList [ 2])}
Vi kan bruke flatMap () å flate nestede samlinger. Her konverterer vi Strenger til List og unngå å ende opp med Liste:
@Test fun whenApplyMultiOutputFunctionToAllItems_thenSuccess () {val theList = listOf ("John", "Tom") val resultList = theList.flatMap {it.toLowerCase (). ToList ()} assertEquals (7, resultList.size)}
4.7. Reduksjon
Vi kan opptre brett / reduser operasjon:
@Test fun whenApplyFunctionToAllItemsWithStartingValue_thenSuccess () {val theList = listOf (1, 2, 3, 4, 5, 6) val finalResult = theList.fold (0, {acc, i -> acc + (i * i)}) assertEquals ( 91, finalResult)}
4.8. Chunking
For å dele en samling i biter av en gitt størrelse, kan vi bruke klumpete () metode:
@Test fun whenApplyingChunked_thenShouldBreakTheCollection () {val theList = listOf (1, 2, 3, 4, 5) val chunked = theList.chunked (2) assertThat (chunked.size) .isEqualTo (3) assertThat (chunked.first ()) . inneholder (1, 2) assertThat (chunked [1]). inneholder (3, 4) assertThat (chunked.last ()). inneholder (5)}
Siden samlingen har fem elementer, har klumpete (2) method call returnerer to samlinger med to elementer hver og en enkeltelementsamling.
Det er også mulig å kartlegge hver del til noe annet etter å ha brutt opp samlingen:
@Test fun whenApplyingChunkedWithTransformation_thenShouldBreakTheCollection () {val theList = listOf (1, 2, 3, 4, 5) val chunked = theList.chunked (3) {it.joinToString (",")} assertThat (chunked.size) .isEqualTo 2) assertThat (chunked.first ()). IsEqualTo ("1, 2, 3") assertThat (chunked.last ()). IsEqualTo ("4, 5")}
Etter å ha laget biter av størrelse 3, konverterer vi hver del til en komma-separert streng.
4.9. Windowing
De vindu () funksjon returnerer en liste over elementområder ved å flytte et skyvevindu av en gitt størrelse over en samling av elementer.
For å bedre forstå dette, la oss se hvordan vindusvindu (3) jobber med en samling av 6 elementer:
Først er vindusstørrelsen 3, derfor vil den første listen inneholde 1, 2 og 3. Deretter beveger skyvevinduet ett element videre:
Skyvevinduet beveger seg fremover til det ikke klarer å opprette en annen liste med gitt størrelse:
Denne overgangssekvensen manifesterer seg i Kotlin-koden som:
@Test fun whenApplyingWindowed_thenShouldCreateSlidingWindowsOfElements () {val theList = (1..6) .toList () val windowed = theList.windowed (3) assertThat (windowed.size) .isEqualTo (4) assertThat (windowed.first ()). (1, 2, 3) assertThat (windowed [1]). Inneholder (2, 3, 4) assertThat (windowed [2]). Inneholder (3, 4, 5) assertThat (windowed.last ()). Inneholder ( 4, 5, 6)}
Som standard beveger skyvevinduet seg et skritt videre hver gang. Vi kan selvfølgelig endre det ved å sende en tilpasset trinnverdi:
@Test fun whenApplyingWindowedWithTwoSteps_thenShouldCreateSlidingWindowsOfElements () {val theList = (1..6) .toList () val windowed = theList.windowed (size = 3, step = 2) assertThat (windowed.size) .isEqualTo (2) assert. første ()). inneholder (1, 2, 3) assertThat (windowed.last ()). inneholder (3, 4, 5)}
De vindu () funksjon oppretter som standard alltid og bare områder av den gitte størrelsen. For å endre det, kan vi stille inn partialWindows parameter til ekte:
@Test fun whenApplyingPartialWindowedWithTwoSteps_thenShouldCreateSlidingWindowsOfElements () {val theList = (1..6) .toList () val windowed = theList.windowed (size = 3, step = 2, partialWindows = true) assertThat (windowed.size). assertThat (windowed.first ()). inneholder (1, 2, 3) assertThat (windowed [1]). inneholder (3, 4, 5) assertThat (windowed.last ()). inneholder (5, 6)}
I likhet med klumpete () funksjon, er det mulig å kartlegge hvert område til noe annet:
@Test moro når du brukerTransformingWindows_thenShouldCreateSlidingWindowsOfElements () {val theList = (1..6) .toList () val windowed = theList.windowed (size = 3, step = 2, partialWindows = true) {it.joinToString (",")} assertThat (windowed.size) .isEqualTo (3) assertThat (windowed.first ()). isEqualTo ("1, 2, 3") assertThat (windowed [1]). isEqualTo ("3, 4, 5") assertThat (windowed .last ()). isEqualTo ("5, 6")}
5. Konklusjon
Vi utforsket Kotlins Collections API og noen av de mest interessante metodene.
Og som alltid kan hele kildekoden finnes på GitHub.