为什么Kotlin具有集合的Mutable版本？

如何解决为什么Kotlin具有集合的Mutable版本？

我对Kotlin系列有一个一般性的问题。

当我们拥有MutableList与val的区别时，为什么会有这么多集合（例如var）的可变版本？

好吧......好吧...实际上，我知道val与对象的“可变性”无关，而是与对象的“可重新初始化性”无关。

但这又引发了一个问题。...MutableList为什么不是默认值？

解决方法

TL; DR

可变的和不可变的集合可以单独暴露无法在单个界面中共存的有用功能：

1. 可变的集合可以从读取，也可以写入。但是Kotlin努力避免所有运行时失败，因此，这些可变集合是不变的。
2. 不变的集合是协变的，但它们...很好...不变的。尽管如此，Kotlin确实提供了使用这些不可变集合做有用的事情的机制（例如过滤值或从现有集合中创建新的不可变集合）。您可以通过the long list of convenience functions for Kotlin's (immutable) List interface为例。

---

Kotlin中的不可变集合不能添加或删除元素。它们只能从中读取。但是这种明显的限制使得可以对不可变的集合进行一些子类型化。来自Kotlin文档：

只读集合类型是协变的...集合类型与元素类型具有相同的子类型关系。

这意味着，如果Rectangle类是Shape类的子级，则可以在需要时将List<Rectangle>对象放在List<Shape>变量中：>

fun stackShapes(val shapesList: List<Shape>) {
    ...
}

val rectangleList = listOf<Rectangle>(...)

// This is valid!
stackShapes(rectangleList)

另一方面，

可变的集合可以从读取，也可以写入。因此，它们不可能有子类型或超级类型。来自Kotlin文档：

...可变集合不是协变的；否则，将导致运行时失败。如果MutableList<Rectangle>是MutableList<Shape>的子类型，则可以在其中插入其他Shape继承者（例如Circle），从而违反其Rectangle类型参数。

val rectangleList = mutableListOf<Rectangle>(...);
val shapesList: MutableList<Shape> = rectangleList // MutableList<Rectangle>-type object in MutableList<Shape>-type variable

val circle = Circle(...)
val shape: Shape = circle // Circle-type object in Shape-type variable

// Runtime Error!
shapesList.add(shape) // You're actually trying to add a Circle to a MutableList<Rectangle>
// If rectanglesList couldn't be put into a variable with type MutableList<Shape> in the first place,you would never have run into this problem.

在这一点上，您可能会想：“那又如何？Kotlin可以将类型检查添加到Mutable Collections的所有写方法中……然后，您可以让它们成为协变，和您将不需要单独的不可变集合！”

这是正确的，除了它将完全违背科特林的核心哲学；尽可能避免nulls和运行时错误。您会发现，每当类型检查失败时，此类Collection的方法都必须返回null或引发异常。这只会在运行时变得明显，并且因为可以通过简单地使Mutable Collections不变而避免...这正是Kotlin所做的。

,

来自Kotlin文档：

只读集合类型是协变的。这意味着，如果Rectangle类从Shape继承，则可以在需要List<Rectangle>的任何地方使用List<Shape>。换句话说，集合类型与元素类型具有相同的子类型关系。映射在值类型上是协变的，但在键类型上不是。

反过来，可变集合不是协变的；否则，将导致运行时失败。如果MutableList<Rectangle>是MutableList<Shape>的子类型，则可以在其中插入其他Shape继承者（例如Circle），从而违反其Rectangle类型参数。

换句话说，如果它是不可变的，那么您知道所有类型都是相同的。如果没有，您可能具有不同的继承者。