Diferencia entre los types de list y matriz en Kotlin

¿Cuál es la diferencia entre los types List y Array ?
Parece que puede hacer las mismas operaciones con ellos (loops, expresión de filter, 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)

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

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

List<T> y MutableList<T> son interfaces que tienen diferentes implementaciones: ArrayList<T> , LinkedList<T> etc. Representación de la memory y lógica de operaciones de las lists se definen en la implementación concreta, por ejemplo, la indexing en LinkedList<T> pasa los enlaces y toma O (n) time, mientras que ArrayList<T> almacena sus elementos en una matriz dinámicamente asignada.
```
 val list1: List<Int> = LinkedList<Int>() val list2: List<Int> = ArrayList<Int>() 
```
Array<T> es mutable (se puede cambiar mediante cualquier reference), pero List<T> no tiene methods de modificación (es una vista de sólo lectura de MutableList<T> o una implementación de list 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 networkingucir la retención de identidad (debe copyr una matriz para networkingimensionarla). En cuanto a las lists, MutableList<T> tiene funciones de add y remove , por lo que puede boost y networkingucir 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 invariable en T ( Array<Int> no es Array<Number> ), lo mismo para MutableList<T> , pero 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. CharArray que están mapeados a matrices primitivas de Java ( int[] , double[] , char[] ), no enmarcadas ( Array<Int> está mapeado en Integer[] de Java Integer[] ). Las lists en general no tienen implementaciones optimizadas para primitivas.
List<T> y MutableList<T> son types mapeados y tienen un comportamiento especial en la interoperabilidad de Java (la List<T> Java List<T> se ve desde Kotlin como List<T> o MutableList<T> ). Las matrices también están mapeadas, pero tienen otras reglas de interoperabilidad Java.
Ciertos types de matriz se utilizan en annotations (matrices primitivas, Array<String> y matrices con inputs de enum class ), y existe una syntax de matriz especial para annotations . Las lists y otras collections no se pueden usar en annotations.
En cuanto al uso, una buena práctica es preferir el uso de lists en las matrices de todo el mundo, excepto en las partes críticas de performance de su código, los arguments son los mismos que los de Java .

La principal diferencia con respecto al uso es que las matrices tienen un tamaño fijo, mientras que la list (Mutable)List puede ajustar su tamaño de forma dinámica. Además Array es mutable mientras que List no lo es.

Además, kotlin.collections.List es una interfaz implementada entre otros por java.util.ArrayList . También se amplía mediante kotlin.collections.MutableList para ser utilizado cuando se necesitan collections que permitan la modificación del elemento.

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