TOC

Vue d’ensemble de l’API Kotlin Collections

Vue d'ensemble de l'API Kotlin Collections

1. Vue d'ensemble

Dans ce rapide tutoriel, nous présenterons l'API Collections de Kotlin, et nous discuterons des différents types de collections dans Kotlin et de certaines opérations courantes sur les collections.

2. Collection vs. Collection Mutable

Tout d'abord, examinons différents types de collections à Kotlin. Nous verrons comment initialiser les types de base des collections.

L'interface deCollection prend en charge les méthodes en lecture seule tandis queMutableCollection prend en charge les méthodes de lecture / écriture.

2.1. List

Nous pouvons créer un simpleList en lecture seule en utilisant la méthodelistOf() et en lecture-écritureMutableList en utilisantmutableListOf(): 

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

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

2.2. Set

De même, nous pouvons créer unSet en lecture seule en utilisant la méthodesetOf() et en lecture-écritureMutableSet en utilisantmutableSetOf(): 

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

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

2.3. Map

Nous pouvons également créer unMap en lecture seule en utilisant la méthodemapOf() et en lecture-écritureMutableMap en utilisantmutableMapOf(): 

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. Opérateurs utiles

L'API Collections de Kotlin est beaucoup plus riche que celle que nous pouvons trouver en Java - elle est livrée avec un ensemble d'opérateurs surchargés.

3.1. L'opérateur «in”

Nous pouvons utiliser l'expression «x in collection» qui peut être traduite encollection.contains(x): 

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

    assertTrue("two" in theList)
}

3.2. L'opérateur“+”

Nous pouvons faire passer un élément ou une collection entière à un autre en utilisant l'opérateur “+”: 

@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. L'opérateur“-“

De même, nous pouvons supprimer un élément ou plusieurs éléments en utilisant l'opérateur «-»: 

@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. Autres méthodes

Enfin, nous explorerons quelques méthodes courantes de collecte. En Java, si nous voulions tirer parti des méthodes avancées, nous aurions besoin d'utiliser l'APIStream.

Dans Kotlin, nous pouvons trouver des méthodes similaires disponibles dans l'API Collections.

On peut obtenir une sous-liste à partir d'unList: donné 

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

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

Nous pouvons facilement supprimer tous les nulls d'unList: 

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

    assertEquals(3, resultList.size)
}

Nous pouvons filtrer facilement les éléments de collection en utilisant le filtre(), qui fonctionne de manière similaire à la méthodefilter() de l'API JavaStream: 

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

Nous pouvons déposer les N premiers éléments: 

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

Nous pouvons déposer les articles en premier s'ils remplissent la condition donnée: 

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

Nous pouvons regrouper des éléments: 

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

Nous pouvons mapper tous les éléments en utilisant la fonction fournie: 

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

Nous pouvons utiliserflatmap() pour aplatir les collections imbriquées. Ici, nous convertissonsStrings en List<String> et évitons de finir avecList<List<String>>: 

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

    assertEquals(7, resultList.size)
}

Nous pouvons effectuer l'opérationfold/reduce: 

@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. Conclusion

Nous avons exploré l'API Collections de Kotlin et certaines des méthodes les plus intéressantes.

Et, comme toujours, le code source complet peut être trouvéover on GitHub.

Related