variable - Diferencia entre los tipos de lista y matriz en Kotlin

kotlin map example

Question

¿Cuál es la diferencia entre los tipos List y Array ?
Parece que puede hacer las mismas operaciones con ellos (bucles, expresión de filtro, etc.), ¿hay alguna diferencia en el comportamiento o el uso?

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

for (name in names1)
    println(name)
for (name in names2)
    println(name)

Answer 1

** en general, la diferencia entre los tipos de Lista y Array es: **

List<...>:

por solo leer.

Array<...>:

puedes modificarlo o agregar algo.

Answer 2

La principal diferencia con respecto al uso es que las Arrays tienen un tamaño fijo, mientras que la lista MutableList<T> puede ajustar su tamaño dinámicamente. Además, la Array es mutable, mientras que la List no lo es.

Además, kotlin.collections.List es una interfaz implementada entre otros por java.util.ArrayList . También se extiende mediante kotlin.collections.MutableList para usarse cuando se necesitan colecciones que permitan la modificación de elementos.

En el nivel jvm, la Array está representada por arrays . List por otro lado, está representada por java.util.List ya que no hay equivalentes de colecciones inmutables disponibles en Java.

Answer 3

Arrays y las listas (representadas por List<T> y su subtipo MutableList<T> ) tienen muchas diferencias, estas son las más importantes:

• Array<T> es una clase con implementación conocida: es una región de memoria secuencial de tamaño fijo que almacena los elementos (y en JVM está representada por una matriz Java ).

  List<T> y MutableList<T> son interfaces que tienen implementaciones diferentes: ArrayList<T> , LinkedList<T> etc. La representación de la memoria y la lógica de operaciones de las listas se definen en una implementación concreta, por ejemplo, la indexación en LinkedList<T> pasa por los enlaces y toma tiempo O (n) mientras que ArrayList<T> almacena sus elementos en una matriz asignada dinámicamente.

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

• Array<T> es mutable (se puede cambiar mediante cualquier referencia), pero List<T> no tiene métodos de modificación (es una vista de solo lectura de MutableList<T> o una implementación de lista inmutable ).

  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

• Las matrices tienen un tamaño fijo y no pueden expandir o reducir la retención de identidad (debe copiar una matriz para cambiar su tamaño). En cuanto a las listas, MutableList<T> tiene funciones de add y remove , para que pueda aumentar y reducir su tamaño.

  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> es invariante en T (la Array<Int> no es la Array<Number> ), lo mismo para MutableList<T> , pero la List<T> es covariante ( List<Int> es List<Number> ).

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

• Las matrices están optimizadas para primitivas: hay IntArray , IntArray , DoubleArray , etc., que se asignan a matrices primitivas de Java ( int[] , double[] , char[] ), no boxed ( Array<Int> se asigna a Integer[] de Java Integer[] ) Las listas en general no tienen implementaciones optimizadas para primitivas, aunque algunas bibliotecas (fuera de JDK) proporcionan listas optimizadas para primitivas.

• List<T> y MutableList<T> son tipos mapeados y tienen un comportamiento especial en la interoperabilidad de Java (la List<T> de Java List<T> se ve desde Kotlin como List<T> o MutableList<T> ). Las matrices también se asignan, pero tienen otras reglas de interoperabilidad Java.

• Ciertos tipos de matriz se usan en annotations (matrices primitivas, Array<String> y matrices con entradas de enum class ), y hay una sintaxis literal de matriz especial para las anotaciones . Las listas y otras colecciones no se pueden usar en anotaciones.

• En cuanto al uso, una buena práctica es preferir el uso de listas en lugar de matrices en todas partes, excepto para las partes críticas del rendimiento de su código, el razonamiento es el mismo que para Java .