在Kotlin中以不同的方式定义List集合:

Immutable variable with immutable (read only) list: val users: List<User> = listOf( User("Tom", 32), User("John", 64) ) Immutable variable with mutable list: val users: MutableList<User> = mutableListOf( User("Tom", 32), User("John", 64) ) or without initial value - empty list and without explicit variable type: val users = mutableListOf<User>() //or val users = ArrayList<User>() you can add items to list: users.add(anohterUser) or users += anotherUser (under the hood it's users.add(anohterUser))

可变变量与不可变列表: var users: List<User> = listOf(User("Tom"， 32)， User("John"， 64)) 或者没有初始值-空列表且没有显式变量类型: var users = emptyList<用户>() 注意:您可以在列表中添加*项: users += anotherUser - *它创建一个新的数组列表并将其分配给用户

Mutable variable with mutable list: var users: MutableList<User> = mutableListOf( User("Tom", 32), User("John", 64) ) or without initial value - empty list and without explicit variable type: var users = emptyList<User>().toMutableList() //or var users = ArrayList<User>() NOTE: you can add items to list: users.add(anohterUser) but not using users += anotherUser Error: Kotlin: Assignment operators ambiguity: public operator fun Collection.plus(element: String): List defined in kotlin.collections @InlineOnly public inline operator fun MutableCollection.plusAssign(element: String): Unit defined in kotlin.collections

参见: https://kotlinlang.org/docs/reference/collections.html

在Kotlin中，你必须使用可变列表或数组列表。

让我们看看MutableList的方法是如何工作的:

var listNumbers: MutableList<Int> = mutableListOf(10, 15, 20)
// Result: 10, 15, 20

listNumbers.add(1000)
// Result: 10, 15, 20, 1000

listNumbers.add(1, 250)
// Result: 10, 250, 15, 20, 1000

listNumbers.removeAt(0)
// Result: 250, 15, 20, 1000

listNumbers.remove(20)
// Result: 250, 15, 1000

for (i in listNumbers) { 
    println(i) 
}

让我们看看ArrayList的方法是如何工作的:

var arrayNumbers: ArrayList<Int> = arrayListOf(1, 2, 3, 4, 5)
// Result: 1, 2, 3, 4, 5

arrayNumbers.add(20)
// Result: 1, 2, 3, 4, 5, 20

arrayNumbers.remove(1)
// Result: 2, 3, 4, 5, 20

arrayNumbers.clear()
// Result: Empty

for (j in arrayNumbers) { 
    println(j) 
}

https://kotlinlang.org/docs/reference/collections.html

根据上面的链接列表<E>在Kotlin中是不可变的。 然而，这是可行的:

var list2 = ArrayList<String>()
list2.removeAt(1)

显然，Kotlin的默认List是不可变的。 要有一个可以更改的List，应该如下所示使用MutableList

class TempClass {
    var myList: MutableList<Int>? = null
    fun doSomething() {
        myList = ArrayList<Int>()
        myList!!.add(10)
        myList!!.remove(10)
    }
}

更新 尽管如此，不建议使用MutableList，除非您确实想要更改列表。有关只读集合如何提供更好的编码，请参阅https://hackernoon.com/read-only-collection-in-kotlin-leads-to-better-coding-40cdfa4c6359。

更新:从Kotlin 1.3.70开始，下面的buildList函数可以作为实验函数在标准库中使用，它还有类似的buildSet和buildMap。见https://blog.jetbrains.com/kotlin/2020/03/kotlin - 1 - 3 - 70 - released/。

将可变性限制到构建器

上面的答案正确地说明了Kotlin中只读列表(注意:它是只读的，不是“不可变的”)和MutableList之间的区别。

一般来说，应该尽量使用只读列表，但是，在构造时，可变性仍然很有用，特别是在处理具有非函数接口的第三方库时。对于无法使用其他构造技术的情况，比如直接使用listOf，或者应用像fold或reduce这样的函数式构造，像下面这样简单的“构造器函数”构造可以很好地从临时可变列表生成只读列表:

val readonlyList = mutableListOf<...>().apply {
  // manipulate your list here using whatever logic you need
  // the `apply` function sets `this` to the `MutableList`
  add(foo1)
  addAll(foos)
  // etc.
}.toList()

这可以很好地封装到一个可重用的内联实用函数中:

inline fun <T> buildList(block: MutableList<T>.() -> Unit) = 
  mutableListOf<T>().apply(block).toList()

可以这样称呼:

val readonlyList = buildList<String> {
  add("foo")
  add("bar")
}

现在，所有的可变性都被隔离到一个用于构造只读列表的块范围中，其余代码使用从构建器输出的只读列表。

你可以像这样创建一个新的。

var list1 = ArrayList<Int>()
var list2  = list1.toMutableList()
list2.add(item)

现在你可以使用list2了，谢谢。