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但不需要使用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

显然，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 4

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

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

或

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

Answer 5

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

根据以上链接列表＆lt; E＆gt;在Kotlin是不变的。 不过这样可行：

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

Answer 6

在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 7

在不可变数据的概念中，也许这是一种更好的方法：

base.Loaded += (sender, e) =>
{
};

Answer 8

list中immutable是Default，您可以改用ArrayList。像这样：

 val orders = arrayListOf<String>()

然后您可以add/delete项如下所示：

orders.add("Item 1")
orders.add("Item 2")

  

默认情况下，ArrayList是mutable，因此您可以对其执行操作。

Answer 9

这里最正确的答案正确地说明了只读saleman sales 3 176 7 152 1 142 Others 510 （注：it's read-only, not "immutable"）和List之间的Kotlin差异。

通常，人们应该努力使用只读列表，但是，可变性在构造时仍然经常有用，尤其是在处理具有非功能接口的第三方库时。对于无法使用替代构造技术的情况，例如直接使用MutableList或应用listOf或fold之类的功能构造，可以使用简单的“ builder function”构造器，如下所示从一个临时可变的列表中产生一个只读列表：

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()

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

Answer 10

您可以创建这样的新对象。

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

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