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.