为什么数组是不变的，而列表是协变的？

Question

例如，为什么可以

val list:List[Any] = List[Int](1,2,3)

工作，但

val arr:Array[Any] = Array[Int](1,2,3)

会失败（因为数组是不变的）。这个设计决策背后的预期效果是什么？

Answer 1

因为否则它会破坏类型安全。
如果没有，您将能够执行以下操作：

val arr:Array[Int] = Array[Int](1,2,3)
val arr2:Array[Any] = arr
arr2(0) = 2.54

并且编译器无法捕获它。

另一方面，列表是不可变的，因此您不能添加非 Int 的内容

Answer 2

这是因为列表是不可变的，而数组是可变的。

Answer 3

通常给出的答案是，可变性与协变相结合会破坏类型安全。对于收藏来说，这可以作为一个基本真理。但该理论实际上适用于任何泛型类型，而不仅仅是像 List 和 Array 这样的集合，而且我们根本不需要尝试和推理可变性。

真正的答案与函数类型与子类型交互的方式有关。简而言之，如果类型参数用作返回类型，那么它是协变的。另一方面，如果类型参数用作参数类型，则它是逆变的。如果它既用作返回类型又用作参数类型，则它是不变的。

让我们看一下 Array[T] 的文档 。要查看的两个明显的方法是用于查找和更新的方法：

def apply(i: Int): T
def update(i: Int, x: T): Unit

在第一个方法中 T 是返回类型，而在第二个方法中 T 是参数类型。因此，方差规则规定 T 必须是不变的。

我们可以比较 List[A] 的文档 看看为什么它是协变的。令人困惑的是，我们会发现这些方法类似于 Array[T] 的方法：

def apply(n: Int): A
def ::(x: A): List[A]

由于 A 既用作返回类型又用作参数类型，因此我们期望 A 是不变的，就像 Array[T] 的 T 一样。然而，与Array[T]不同的是，文档在::的类型上对我们撒了谎。对于大多数对此方法的调用来说，谎言已经足够好了，但不足以决定 A 的方差。如果我们展开此方法的文档并单击“完整签名”，我们就会看到真相：

def ::[B >: A](x: B): List[B]

因此 A 实际上并不显示为参数类型。相反，B（可以是 A 的任何超类型）是参数类型。这不会对 A 施加任何限制，因此它确实可以是协变的。 List[A] 上以 A 作为参数类型的任何方法都是类似的谎言（我们可以看出，因为这些方法被标记为 [use case]< /代码>）。

Answer 4

区别在于 List 是不可变的，而 Array 是可变的。

要理解为什么可变性决定方差，请考虑制作 List 的可变版本 - 我们称之为 MutableList。我们还将使用一些示例类型：一个基类 Animal 和 2 个名为 Cat 和 Dog 的子类。

trait Animal {
  def makeSound: String
}

class Cat extends Animal {
  def makeSound = "meow"
  def jump = // ...
}

class Dog extends Animal {
  def makeSound = "bark"
}

请注意，Cat 比 Dog 多了一种方法 (jump)。

然后，定义一个接受可变动物列表并修改该列表的函数：

def mindlessFunc(xs: MutableList[Animal]) = {
  xs += new Dog()
}

现在，如果将猫列表传递到该函数中，将会发生可怕的事情：

val cats = MutableList[Cat](cat1, cat2)
val horror = mindlessFunc(cats)

如果我们使用粗心的编程语言，这将在编译过程中被忽略。尽管如此，如果我们只使用以下代码访问猫列表，我们的世界不会崩溃：

cats.foreach(c => c.makeSound)

但如果我们这样做：

cats.foreach(c => c.jump)

就会发生运行时错误。使用 Scala，可以防止编写此类代码，因为编译器会抱怨。