streamalism.org

1. Áttekintés

Ebben a gyors bemutatóban bemutatjuk a Kotlin Gyűjtemények API-t, és megbeszéljük a különböző gyűjteményes típusokat Kotlinban, valamint néhány általános műveletet a gyűjteményekkel kapcsolatban.

2. Gyűjtemény vs. megváltoztatható gyűjtemény

Először vessünk egy pillantást a Kotlin különböző gyűjteményeire. Meglátjuk, hogyan lehet inicializálni a gyűjtemények alaptípusait.

A Gyűjtemény interfész támogatja a csak olvasható módszereket MutableCollection támogatja az olvasási / írási módszereket.

2.1. Lista

Készíthetünk egy egyszerű, csak olvashatót Lista módszer segítségével listája() és olvasni-írni MutableList felhasználásával mutableListOf ():

val theList = listOf ("egy", "kettő", "három") val theMutableList = mutableListOf ("egy", "kettő", "három")

2.2. Készlet

Hasonlóképpen létrehozhatunk csak olvashatót is Készlet módszer segítségével készlet() és olvasni-írni MutableSet felhasználásával mutableSetOf ():

val theSet = setOf ("egy", "kettő", "három") val theMutableSet = mutableSetOf ("egy", "kettő", "három")

2.3. Térkép

Létrehozhatunk csak olvashatót is Térkép módszer segítségével mapOf () és olvasni-írni MutableMap felhasználásával mutableMapOf ():

val theMap = mapOf (1 - "egy", 2 - "kettő", 3 - "három") val theMutableMap = mutableMapOf (1 - "egy", 2 - "kettő", 3 - "három")

3. Hasznos üzemeltetők

A Kotlin Gyűjtemények API-ja sokkal gazdagabb, mint amit a Java-ban találunk - túlterhelt operátorokkal rendelkezik.

3.1. A "ban ben" Operátor

Használhatjuk a következő kifejezést:x a gyűjteményben”Fordítható collection.contains (x):

@Test fun whenSearchForExistingItem_thenFound () {val theList = listOf ("egy", "kettő", "három") assertTrue ("kettő" a listában)}

3.2. A “+” Operátor

Elemeket vagy teljes gyűjteményeket átadhatunk egy másiknak a „+” operátor használatával:

@Test fun whenJoinTwoCollections_thenSuccess () {val firstList = listOf ("one", "two", "three") val secondList = listOf ("four", "five", "hat") val resultList = firstList + secondList assertEquals (6 , resultList.size) assertTrue (resultList.contains ("kettő")) assertTrue (resultList.contains ("öt"))}

3.3. A “-“ Operátor

Hasonlóképpen eltávolíthatunk egy elemet vagy több elemet a „-” operátor használatával:

@Test fun whenExcludeItems_thenRemoved () {val firstList = listOf ("one", "two", "three") val secondList = listOf ("one", "three") val resultList = firstList - secondList assertEquals (1, resultList.size ) assertTrue (resultList.contains ("kettő"))}}

4. Egyéb módszerek

Végül feltárunk néhány általános módszert a gyűjtésre. A Java-ban, ha fejlett módszereket akarunk kihasználni, akkor használnunk kell Folyam API.

Kotlinban hasonló módszereket találhatunk a Collections API-ban.

4.1. Szeletelés

Adottaktól kaphatunk allistát Lista:

@Test fun whenSliceCollection_thenSuccess () {val theList = listOf ("one", "two", "three") val resultList = theList.slice (1..2) assertEquals (2, resultList.size) assertTrue (resultList.contains ( "kettő")) }

4.2. Eltávolítás

Könnyen eltávolíthatjuk az összes nullát az a-ból Lista:

@Test fun whenFilterNullValues_thenSuccess () {val theList = listOf ("one", null, "two", null, "three") val resultList = theList.filterNotNull () assertEquals (3, resultList.size)}

4.3. Szűrő

A gyűjtemény segítségével könnyen szűrhetjük a szűrőt(), amely hasonlóan működik a szűrő() módszer a Java-ból Folyam 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. tartalmazza (1)) assertFalse (resultList.contains (-4))}

4.4. Csepegés

Dobhatjuk az első N elemet:

@Test fun whenDropFirstItems_thenRemoved () {val theList = listOf ("one", "two", "three", "four") val resultList = theList.drop (2) assertEquals (2, resultList.size) assertFalse (resultList.contains ("egy")) assertFalse (resultList.contains ("kettő"))}}

Az első néhány elemet eldobhatjuk, ha megfelelnek az adott feltételnek:

@Test fun whenDropFirstItemsBasedOnCondition_thenRemoved () {val theList = listOf ("one", "two", "three", "four") val resultList = theList.dropWhile {it.length <4} assertEquals (2, resultList.size) assertFalse (resultList.contains ("egy")) assertFalse (resultList.contains ("kettő"))}

4.5. Csoportosítás

Csoportosíthatjuk az elemeket:

@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]! !. tartalmaz (1)) assertTrue (eredménytérkép [2] !!. tartalmazza (5))}

4.6. Térképezés

Minden elemet feltérképezhetünk a megadott függvény segítségével:

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

Tudjuk használni flatMap () beágyazott gyűjtemények ellapítására. Itt konvertálunk Húrok hogy List és kerülve a végét Lista:

@Test fun whenApplyMultiOutputFunctionToAllItems_thenSuccess () {val theList = listOf ("John", "Tom") val resultList = theList.flatMap {it.toLowerCase (). ToList ()} assertEquals (7, resultList.size)}

4.7. Csökkentés

Előadhatunk hajtogat / csökkent művelet:

@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. Dobogó

Ha egy gyűjteményt adott méretű darabokra akarunk bontani, használhatjuk a darabos () módszer:

@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 () .contains (1, 2) assertThat (darabos [1]). tartalmaz (3, 4) assertThat (chunked.last ()). tartalmaz (5)}

Mivel a gyűjtemény öt elemből áll, a darabos (2) A method hívás két gyűjteményt ad vissza két-két elemmel és egy egyelemes gyűjteményt.

A gyűjtemény felbomlása után minden darabot máshoz is lehet hozzárendelni:

@Test fun whenApplyingChunkedWithTransformation_thenShouldBreakTheCollection () {val theList = listOf (1, 2, 3, 4, 5) val chunked = theList.chunked (3) {it.joinToString (",")} assertThat (chunkedqusio). 2) assertThat (chunked.first ()). IsEqualTo ("1, 2, 3") assertThat (chunked.last ()). IsEqualTo ("4, 5")}

A 3. méretű darabok létrehozása után mindegyik darabot vesszővel elválasztott karakterlánccá alakítjuk.

4.9. Ablakozás

A ablakos() A function egy elemtartomány-listát ad vissza, egy adott méretű csúszó ablakot áthelyezve az elemek gyűjteményére.

Ennek jobb megértése érdekében nézzük meg, hogyan ablakos (3) 6 elemből álló gyűjteményen dolgozik:

Eleinte az ablak mérete 3, ezért az első lista 1, 2 és 3-at tartalmazna. Ezután a csúszó ablak egy elemet tovább visz:

A csúszó ablak addig mozog előre, amíg nem sikerül létrehozni a megadott méretű újabb listát:

Ez az átmenetsorozat a Kotlin-kódban a következőképpen nyilvánul meg:

@Test fun whenApplyingWindowed_thenShouldCreateSlidingWindowsOfElements () {val theList = (1..6) .toList () val windowed = theList.windown (3) assertThat (windowed.size) .isEqualTo (4) assertThat (windowed.first ()). (1, 2, 3) assertThat (ablakos [1]). Tartalmaz (2, 3, 4) assertThat (ablakos [2]). Tartalmaz (3, 4, 5) assertThat (windowed.last ()). Tartalmaz ( 4, 5, 6)}

Alapértelmezés szerint a csúszó ablak minden alkalommal egy lépéssel tovább mozog. Természetesen ezen változtathatunk egy egyedi lépésérték átadásával:

@Test fun whenApplyingWindownWithTwoSteps_thenShouldCreateSlidingWindowsOfElements () {val theList = (1..6) .toList () val windowed = theList.windowed (size = 3, step = 2) assertThat (windowed.size) .isEqualThat (2 window). first ()). tartalmaz (1, 2, 3) assertThat (windowed.last ()). tartalmazza (3, 4, 5)}

A ablakos() A function alapértelmezés szerint mindig és csak az adott méretű tartományokat hozza létre. Ennek megváltoztatásához beállíthatjuk a részleges Windows paraméter a igaz:

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

Hasonló a darabos () függvény, az egyes tartományokat másra lehet leképezni:

@Test fun whenApplyingTransformingWindows_thenShouldCreateSlidingWindowsOfElements () {val theList = (1..6) .toList () val windowed = theList.windown (size = 3, step = 2, partsWindows = true) {it.joinToString (",")} assertThat (windowed.size) .isEqualTo (3) assertThat (windowed.first ()). isEqualTo ("1, 2, 3") assertThat (ablakos [1]). isEqualTo ("3, 4, 5") assertThat (ablakos) .last ()). isEqualTo ("5, 6")}

5. Következtetés

Felfedeztük a Kotlin Collections API-t és a legérdekesebb módszereket.

És mint mindig, a teljes forráskód megtalálható a GitHubon.