streamalism.org

1. Oversigt

I denne hurtige vejledning introducerer vi Kotlins Collections API, og vi diskuterer de forskellige samlingstyper i Kotlin og nogle almindelige operationer på samlinger.

2. Samling vs. mutabil samling

Lad os først se på forskellige typer samlinger i Kotlin. Vi vil se, hvordan man initialiserer de grundlæggende typer samlinger.

Det Kollektion interface understøtter skrivebeskyttede metoder mens MutableCollection understøtter læse / skrive metoder.

2.1. Liste

Vi kan oprette en simpel skrivebeskyttet Liste ved hjælp af metode liste af() og læse-skrive MutableList ved brug af mutableListOf ():

val theList = listOf ("one", "two", "three") val theMutableList = mutableListOf ("one", "two", "three")

2.2. Sæt

På samme måde kan vi oprette en skrivebeskyttet Sæt ved hjælp af metode sæt af() og læse-skrive MutableSet ved brug af mutableSetOf ():

val theSet = setOf ("one", "two", "three") val theMutableSet = mutableSetOf ("one", "two", "three")

2.3. Kort

Vi kan også oprette en skrivebeskyttet Kort ved hjælp af metode mapOf () og læse-skrive MutableMap ved brug af 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 meget rigere end den, vi kan finde i Java - den kommer med et sæt overbelastede operatører.

3.1. Det "i" Operatør

Vi kan bruge udtryk “x i samlingen”Som kan oversættes til collection.contains (x):

@Test sjov nårSearchForExistingItem_thenFound () {val theList = listOf ("one", "two", "three") assertTrue ("two" in theList)}

3.2. Det “+” Operatør

Vi kan et element eller en hel samling til en anden ved hjælp af "+" operator:

@Test sjov 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. Det “-“ Operatør

På samme måde kan vi fjerne et element eller flere elementer ved hjælp af "-" operator:

@ Test sjovt 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

Endelig vil vi undersøge nogle almindelige metoder til indsamling. Hvis vi i Java ønsker at udnytte avancerede metoder, skal vi bruge dem Strøm API.

I Kotlin kan vi finde lignende metoder tilgængelige i Collections API.

4.1. Skæring

Vi kan få en underliste fra en given Liste:

@Test sjovt 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 nemt fjerne alle nuller fra en Liste:

@ Test sjov nårFilterNullValues_thenSuccess () {val theList = listOf ("one", null, "two", null, "three") val resultList = theList.filterNotNull () assertEquals (3, resultList.size)}

4.3. Filtrering

Vi kan nemt filtrere indsamlingsgenstande ved hjælp af filter(), der fungerer på samme måde som filter() metode fra Java Strøm API:

@Test sjovt nårFilterNonPositiveValues_thenSuccess () {val theList = listOf (1, 2, -3, -4, 5, -6) val resultList = theList.filter {it> 0} assertEquals (3, resultList.size) assertTrue (resultList. indeholder (1)) assertFalse (resultList.contains (-4))}

4.4. Faldende

Vi kan droppe de første N-emner:

@Test sjov 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 droppe de første par ting, hvis de opfylder den givne betingelse:

@Test sjov 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 sjov nårGroupItems_thenSuccess () {val theList = listOf (1, 2, 3, 4, 5, 6) val resultMap = theList.groupBy {it% 3} assertEquals (3, resultMap.size) assertTrue (resultMap [1]! ! .indholder (1)) assertTrue (resultMap [2] !!. indeholder (5))}

4.6. Kortlægning

Vi kan kortlægge alle elementer ved hjælp af den medfølgende funktion:

@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 bruge flatMap () for at flade indlejrede samlinger. Her konverterer vi Strenge til List og undgå at ende med Liste:

@Test sjov nårApplyMultiOutputFunctionToAllItems_thenSuccess () {val theList = listOf ("John", "Tom") val resultList = theList.flatMap {it.toLowerCase (). ToList ()} assertEquals (7, resultList.size)}

4.7. Reduktion

Vi kan udføre fold / reducer operation:

@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 at opdele en samling i bidder af en given størrelse kan vi bruge klumpet () metode:

@Test sjov når du anvenderChunked_thenShouldBreakTheCollection () {val theList = listOf (1, 2, 3, 4, 5) val chunked = theList.chunked (2) assertThat (chunked.size) .isEqualTo (3) assertThat (chunked.first ()) . indeholder (1, 2) assertThat (chunked [1]). indeholder (3, 4) assertThat (chunked.last ()). indeholder (5)}

Da samlingen har fem elementer, er klumpet (2) metode kald returnerer to samlinger med to elementer hver og en enkelt-element samling.

Det er også muligt at kortlægge hvert stykke til noget andet efter opdelingen af ​​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")}

Efter at have oprettet klumper af størrelse 3 konverterer vi hver klump til en komma-adskilt streng.

4.9. Windowing

Det vinduesvindue () -funktionen returnerer en liste over elementområder ved at flytte et glidende vindue af en given størrelse over en samling af elementer.

For bedre at forstå dette, lad os se hvordan vinduesvindue (3) arbejder på en samling af 6 elementer:

Først er vinduesstørrelsen 3, derfor vil den første liste indeholde 1, 2 og 3. Derefter bevæger glidevinduet et element videre:

Skydevinduet bevæger sig fremad, indtil det ikke opretter en anden liste med den givne størrelse:

Denne sekvens af overgange manifesterer sig 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]). Indeholder (2, 3, 4) assertThat (windowed [2]). Indeholder (3, 4, 5) assertThat (windowed.last ()). Indeholder ( 4, 5, 6)}

Som standard bevæger glidevinduet et skridt videre hver gang. Vi kan selvfølgelig ændre det ved at overføre en tilpasset trinværdi:

@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 ()). indeholder (1, 2, 3) assertThat (windowed.last ()). indeholder (3, 4, 5)}

Det vinduesvindue () funktion opretter som standard altid og kun områder af den givne størrelse. For at ændre det kan vi indstille partialWindows parameter til rigtigt:

@Test fun whenApplyingPartialWindowedWithTwoSteps_thenShouldCreateSlidingWindowsOfElements () {val theList = (1..6) .toList () val windowed = theList.windowed (size = 3, step = 2, partialWindows = true) assertThat (windowed.sizeTo). assertThat (windowed.first ()). indeholder (1, 2, 3) assertThat (windowed [1]). indeholder (3, 4, 5) assertThat (windowed.last ()). indeholder (5, 6)}

Svarende til klumpet () funktion, er det muligt at kortlægge hvert interval til noget andet:

@Test sjovt, når du anvenderTransformingWindows_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. Konklusion

Vi udforskede Kotlins Collections API og nogle af de mest interessante metoder.

Og som altid kan den fulde kildekode findes på GitHub.