Überblick über die Kotlin Collections API

Übersicht über die Kotlin Collections API

1. Überblick

In diesem kurzen Tutorial stellen wir die Sammlungs-API von Kotlin vor und erläutern die verschiedenen Sammlungstypen in Kotlin sowie einige allgemeine Vorgänge für Sammlungen.

2. Sammlung vs. Veränderliche Sammlung

Schauen wir uns zunächst verschiedene Arten von Sammlungen in Kotlin an. Wir werden sehen, wie grundlegende Arten von Sammlungen initialisiert werden.

DieCollection-Schnittstelle unterstützt schreibgeschützte Methoden, währendMutableCollectiondie Lese- / Schreibmethoden unterstützt.

2.1. List

Wir können einfache schreibgeschützteList mit der MethodelistOf() und schreibgeschützteMutableList mitmutableListOf() erstellen:

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

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

2.2. Set

In ähnlicher Weise können wir schreibgeschützteSet mit der MethodesetOf() und schreibgeschützteMutableSet mitmutableSetOf() erstellen:

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

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

2.3. Map

Wir können auch schreibgeschützteMap mit der MethodemapOf() und schreibgeschützteMutableMap mitmutableMapOf() erstellen:

val theMap = mapOf(1 to "one", 2 to "two", 3 to "three")

val theMutableMap = mutableMapOf(1 to "one", 2 to "two", 3 to "three")

3. Nützliche Operatoren

Die Sammlungs-API von Kotlin ist viel umfangreicher als die in Java - sie enthält eine Reihe überladener Operatoren.

3.1. Der Operator „in”

Wir können den Ausdruck "x in collection" verwenden, der incollection.contains(x) übersetzt werden kann:

@Test
fun whenSearchForExistingItem_thenFound () {
    val theList = listOf("one", "two", "three")

    assertTrue("two" in theList)
}

3.2. Der Operator“+”

Mit dem Operator "+" können wir ein Element oder eine gesamte Sammlung in eine andere verschieben:

@Test
fun whenJoinTwoCollections_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. Der Operator“-“

Ebenso können wir ein Element oder mehrere Elemente mit dem Operator "-" entfernen:

@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("two"))
}

4. Andere Methoden

Schließlich werden wir einige gängige Methoden für die Sammlung untersuchen. Wenn wir in Java erweiterte Methoden nutzen möchten, müssen wir die API vonStreamverwenden.

In Kotlin finden Sie ähnliche Methoden in der Collections-API.

Wir können eine Unterliste aus einem gegebenenList: erhalten

@Test
fun whenSliceCollection_thenSuccess () {
    val theList = listOf("one", "two", "three")
    val resultList = theList.slice(1..2)

    assertEquals(2, resultList.size)
    assertTrue(resultList.contains("two"))
}

Wir können leicht alle Nullen ausList: entfernen

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

    assertEquals(3, resultList.size)
}

Wir können Sammlungselemente einfach mit dem Filter(), filtern, der ähnlich wie diefilter()-Methode aus der JavaStream-API funktioniert:

@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.contains(1))
    assertFalse(resultList.contains(-4))
}

Wir können zuerst N Gegenstände fallen lassen:

@Test
fun whenDropFirstItems_thenRemoved () {
    val theList = listOf("one", "two", "three", "four")
    val resultList = theList.drop(2)

    assertEquals(2, resultList.size)
    assertFalse(resultList.contains("one"))
    assertFalse(resultList.contains("two"))
}

Wir können die ersten paar Gegenstände fallen lassen, wenn sie die gegebene Bedingung erfüllen:

@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("one"))
    assertFalse(resultList.contains("two"))
}

Wir können Elemente gruppieren:

@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]!!.contains(5))
}

Wir können alle Elemente mit der bereitgestellten Funktion abbilden:

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

Wir könnenflatmap() verwenden, um verschachtelte Sammlungen zu reduzieren. Hier konvertieren wirStrings in List<String> und vermeiden, dassList<List<String>> endet:

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

    assertEquals(7, resultList.size)
}

Wir können die Operationfold/reduceausführen:

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

5. Fazit

Wir haben Kotlins Sammlungs-API und einige der interessantesten Methoden untersucht.

Und wie immer kann der vollständige Quellcodeover on GitHub. gefunden werden

TOC