Kotlin的名单缺少"添加","删除"等？

Question

在Java中,我们可以执行以下操作

public class TempClass {
    List<Integer> myList = null;
    void doSomething() {
        myList = new ArrayList<>();
        myList.add(10);
        myList.remove(10);
    }
}

但如果我们直接将其重写为Kotlin,如下所示

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

我从我的列表中得到了没有找到add并remove运行的错误

我努力将它转换为ArrayList,但这需要投射它是奇怪的,而在Java中不需要.这就违背了抽象类List的目的

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

有没有办法让我使用List但不需要投射它,就像在Java中可以做到的那样？

Answer 1

与许多语言不同,Kotlin区分可变集合和不可变集合(列表,集合,映射等).精确控制何时可以编辑集合对于消除错误和设计良好的API非常有用.

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

你需要使用一个MutableList列表.

class TempClass {
    var myList: MutableList<Int> = mutableListOf<Int>()
    fun doSomething() {
        // myList = ArrayList<Int>() // initializer is redundant
        myList.add(10)
        myList.remove(10)
    }
}

MutableList<Int> = arrayListOf() 也应该工作.

Answer 2

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

• 具有不可变(只读)列表的不可变变量:

  val users: List<User> = listOf( User("Tom", 32), User("John", 64) )
  

  
  

• 具有可变列表的不可变变量:

  val users: MutableList<User> = mutableListOf( User("Tom", 32), User("John", 64) )
  

  或没有初始值 - 空列表和没有显式变量类型:

  val users = mutableListOf<User>()
  //or
  val users = ArrayList<User>()
  

  • 您可以将项目添加到列表中:
    • users.add(anohterUser) 要么
    • users += anotherUser(引擎盖下users.add(anohterUser))

• 具有不可变列表的可变变量:

  var users: List<User> = listOf( User("Tom", 32), User("John", 64) )
  

  或没有初始值 - 空列表和没有显式变量类型:

  var users = emptyList<User>()
  

  • 注意:您可以添加*项目到列表:
    • users += anotherUser - *它创建新的ArrayList并将其分配给 users

• 具有可变列表的可变变量:

  var users: MutableList<User> = mutableListOf( User("Tom", 32), User("John", 64) )
  

  或没有初始值 - 空列表和没有显式变量类型:

  var users = emptyList<User>().toMutableList()
  //or
  var users = ArrayList<User>()
  

  • 注意:您可以将项目添加到列表:
    • users.add(anohterUser)
    • 但没有使用 users += anotherUser

      错误:Kotlin:赋值运算符歧义:
      public operator fun Collection.plus(element:String):在kotlin.collections中定义的列表
      @InlineOnly public inline operator fun MutableCollection.plusAssign(element:String):在kotlin.collections中定义的单位

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

Answer 3

同意使用MutableList的所有上述答案，但是您也可以从List添加/删除并获得如下的新列表。

val newListWithElement = existingList + listOf(element)
val newListMinusElement = existingList - listOf(element)

要么

val newListWithElement = existingList.plus(element)
val newListMinusElement = existingList.minus(element)

Answer 4

显然,Kotlin的默认列表是不可变的.要拥有一个可以更改的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为只读集合如何提供更好的编码.

Answer 5

在 Kotlin 中，您必须使用MutableList或ArrayList。

让我们看看这些方法是如何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) 
}

Answer 6

更新：从 Kotlin 1.3.70 开始，标准库中提供了buildList以下确切函数作为实验函数，以及它的类似物和. 请参阅https://blog.jetbrains.com/kotlin/2020/03/kotlin-1-3-70-released/。buildSetbuildMap

将可变性限制在构建器中

此处的最佳答案正确地说明了 Kotlin 中只读List（注意：它是只读的，而不是“不可变的”）和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")
}

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

Answer 7

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

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

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