Difference between List and Array types in Kotlin

Arrays and lists (represented by List<T> and its subtype MutableList<T>) have many differences, here are the most significant ones:

Array is a class with known implementation: it's a sequential fixed-size memory region storing the items (and on JVM it is represented by Java array). List and MutableList are interfaces which have different implementations: ArrayList, LinkedList etc. Memory representation and operations logic of lists are defined in concrete implementation, e.g. indexing in a LinkedList goes through the links and takes O(n) time whereas ArrayList stores its items in a dynamically allocated array. val list1: List = LinkedList() val list2: List = ArrayList()

Array is mutable (it can be changed through any reference to it), but List doesn't have modifying methods (it is either read-only view of MutableList or an 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

Arrays have fixed size and cannot expand or shrink retaining identity (you need to copy an array to resize it). As to the lists, MutableList has add and remove functions, so that it can increase and reduce its size. 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 is invariant on T (Array is not Array), the same for MutableList, but List is covariant (List is List). val a: Array = Array(0) { 0 } // won't compile val l: List = listOf(1, 2, 3) // OK

Arrays are optimized for primitives: there are separate IntArray, DoubleArray, CharArray etc. which are mapped to Java primitive arrays (int[], double[], char[]), not boxed ones (Array is mapped to Java's Integer[]). Lists in general do not have implementations optimized for primitives, though some libraries (outside JDK) provide primitive-optimized lists.

List and MutableList are mapped types and have special behaviour in Java interoperability (Java's List is seen from Kotlin as either List or MutableList). Arrays are also mapped, but they have other rules of Java interoperability.

Certain array types are used in annotations (primitive arrays, Array, and arrays with enum class entries), and there's a special array literal syntax for annotations. Lists and other collections cannot be used in annotations.

As to the usage, good practice is to prefer using lists over arrays everywhere except for performance critical parts of your code, the reasoning is the same to that for Java.

---

The major difference from usage side is that Arrays have a fixed size while (Mutable)List can adjust their size dynamically. Moreover Array is mutable whereas List is not.

Furthermore kotlin.collections.List is an interface implemented among others by java.util.ArrayList. It's also extended by kotlin.collections.MutableList to be used when a collection that allows for item modification is needed.

On the jvm level, Array is represented by arrays. List on the other hand is represented by java.util.List since there are no immutable collections equivalents available in Java.

---

In additional to the above, identity comparison is also different:

val l1 = listOf("a")
val l2 = listOf("a")
var x = (l1 == l2) // => true

val a1 = arrayOf("a")
val a2 = arrayOf("a")
var y = (a1 == a2) // => false

---