Differenza tra i tipi List e Array in Kotlin

Question

Qual è la differenza tra i tipi List e Array?
Sembra che possa fare le stesse operazioni con loro (loop, espressione del filtro, ecc.), C'è qualche differenza nel comportamento o nell'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

Arrays e liste (rappresentanti List<T> e il suo sottotipo MutableList<T>) hanno molte differenze, qui sono i più significativi:

• Array<T> è una classe di implementazione noto: si tratta di una regione di memoria di dimensione fissa sequenziale memorizzando gli articoli (e su JVM è rappresentato da Java array).

  List<T> e MutableList<T> sono interfacce che hanno diverse implementazioni: ArrayList<T>, LinkedList<T> ecc rappresentazione memoria e operazioni logiche di liste sono definite in concreta applicazione, ad esempio l'indicizzazione in un LinkedList<T> passa attraverso i collegamenti e richiede O (n) tempo mentre ArrayList<T> memorizza i suoi elementi in un array allocato dinamicamente.

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

• Array<T> è mutevole (può essere modificato tramite qualsiasi riferimento ad essa), ma List<T> non avere metodi modificanti (è o read-only view of MutableList<T> o immutable list implementation).

  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 
  

• Array hanno fissato dimensioni e non possono espandere o ridurre conservando identità (è necessario copiare una matrice per ridimensionarla). Per quanto riguarda gli elenchi, MutableList<T> ha le funzioni add e remove, in modo che possa aumentare e ridurre le sue dimensioni.

  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> è invariant on T (Array<Int> non è Array<Number>), uguale per MutableList<T>, ma List<T> è covariante (List<Int> è List<Number>).

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

• matrici sono ottimizzati per primitive: ci sono separati IntArray, DoubleArray, CharArray etc.che sono mappati su array primitivi Java (int[], double[], char[]), non su boxed (Array<Int> è mappato su Java Integer[]). Gli elenchi in generale non hanno implementazioni ottimizzate per le primitive, sebbene alcune librerie (al di fuori di JDK) forniscano elenchi ottimizzati per i primitivi.

• List<T> e MutableList<T> sono mapped types e hanno un comportamento speciale interoperabilità Java (di List<T> Java è visto da Kotlin sia come List<T> o MutableList<T>). Gli array sono anche mappati, ma hanno l'interoperabilità Java other rules.

• Alcuni tipi di matrice sono utilizzati in annotations (array primitivi, Array<String> e array con enum class iscrizioni), e c'è una speciale array literal syntax for annotations. Gli elenchi e le altre raccolte non possono essere utilizzati nelle annotazioni.

• Per quanto riguarda l'utilizzo, è buona norma utilizzare elenchi su array in tutto il mondo tranne che per le parti critiche per le prestazioni del codice, il ragionamento è lo stesso per that for Java.

Answer 2

La principale differenza rispetto lato utilizzo è che Arrays ha una dimensione fissa mentre (Mutable)List grado di regolare dinamicamente la loro dimensione. Inoltre Array è modificabile mentre List non lo è.

Inoltre kotlin.collections.List è un'interfaccia implementata tra gli altri da java.util.ArrayList. È inoltre esteso da kotlin.collections.MutableList da utilizzare quando è necessario un insieme di raccolte che consente la modifica di un articolo.

Il livello jvm Array è rappresentato da arrays. List d'altra parte è rappresentato da java.util.List poiché non ci sono equivalenti di collezioni immutabili disponibili in Java.