web-dev-qa-db-fra.com

Différence entre les types List et Array dans Kotlin

Quelle est la différence entre les types List et Array?
Il semble que l'on puisse faire les mêmes opérations avec elles (boucles, expression de filtre, etc.), y a-t-il une différence de comportement ou d'utilisation?

val names1 = listOf("Joe","Ben","Thomas")
val names2 = arrayOf("Joe","Ben","Thomas")

for (name in names1)
    println(name)
for (name in names2)
    println(name)
kotlin
91
Daniel Hári

Les tableaux et les listes (représentés par List<T> et son sous-type MutableList<T> ) présentent de nombreuses différences. Voici les plus importantes:

  • Array<T> est une classe avec une implémentation connue: c'est une région mémoire séquentielle de taille fixe stockant les éléments (et sur la machine virtuelle Java, elle est représentée par le tableau Java ).

    List<T> et MutableList<T> sont des interfaces ayant différentes implémentations: ArrayList<T>, LinkedList<T> etc. La représentation en mémoire et la logique de fonctionnement des listes sont définies dans une implémentation concrète, par exemple. l'indexation dans un LinkedList<T> passe par les liens et prend O(n) fois alors que ArrayList<T> stocke ses éléments dans un tableau alloué de manière dynamique.

    val list1: List<Int> = LinkedList<Int>()
val list2: List<Int> = ArrayList<Int>()

  • Array<T> est modifiable (il peut être changé par n'importe quelle référence), mais List<T> n'a pas de méthode de modification (il s'agit de la vue en lecture seule de MutableList<T> ou d'une implémentation de liste immuable ).

    val a = arrayOf(1, 2, 3)
a[0] = a[1] // OK

val l = listOf(1, 2, 3)
l[0] = l[1] // doesn't compile

val m = mutableListOf(1, 2, 3)
m[0] = m[1] // OK

  • Les tableaux ont une taille fixe et ne peuvent pas être développés ou réduits en conservant l'identité (vous devez copier un tableau pour le redimensionner). En ce qui concerne les listes, MutableList<T> a les fonctions add et remove, de sorte qu’il puisse augmenter et réduire sa taille.

    val a = arrayOf(1, 2, 3)
println(a.size) // will always be 3 for this array

val l = mutableListOf(1, 2, 3)
l.add(4)
println(l.size) // 4

  • Array<T> est invariant sur T (Array<Int> n'est pas Array<Number>), identique à MutableList<T>, mais List<T> est covariant (List<Int> est List<Number>).

    val a: Array<Number> = Array<Int>(0) { 0 } // won't compile
val l: List<Number> = listOf(1, 2, 3) // OK

  • Les tableaux sont optimisés pour les primitives: il existe des variables IntArray, DoubleArray, CharArray etc. mappées sur des matrices de primitives Java (int[], double[], char[]) et non pas encadrées (Array<Int> est mappé sur le Integer[] de Java). En général, les listes ne disposent pas d'implémentations optimisées pour les primitives, bien que certaines bibliothèques (en dehors de JDK) fournissent des listes optimisées pour les primitives.

  • List<T> et MutableList<T> sont des types mappés et ont un comportement particulier en interopérabilité Java (le List<T> de Java est vu à partir de Kotlin sous la forme List<T> ou MutableList<T>). Les tableaux sont également mappés, mais ils ont d'autres règles d'interopérabilité Java.

  • Certains types de tableaux sont utilisés dans annotations (tableaux primitifs, Array<String> et tableaux contenant des entrées enum class), et il existe une syntaxe littérale array particulière pour les annotations . Les listes et autres collections ne peuvent pas être utilisées dans les annotations.

  • En ce qui concerne l'utilisation, il est préférable de préférer utiliser des listes plutôt que des tableaux, sauf pour les parties critiques de votre code, le raisonnement est le même que celui de Java .

160
hotkey

La principale différence par rapport à l'utilisation est que Arrays ont une taille fixe alors que (Mutable)List peut ajuster leur taille de manière dynamique. De plus, Array est mutable alors que List ne l’est pas.

De plus, kotlin.collections.List est une interface implémentée entre autres par Java.util.ArrayList. Il est également étendu de kotlin.collections.MutableList à utiliser lorsqu'un recueil permettant la modification d'éléments est nécessaire.

Au niveau jvm Array est représenté par arrays . List est quant à lui représenté par Java.util.List puisqu’aucun équivalent de collection immuable n’est disponible en Java.

15
miensol

** général, la différence entre les types List et Array est: **

List<...>:

pour seulement lire.

Array<...>:

vous pouvez le modifier ou ajouter quelque chose.

0
Youn Tivoli