Arrays 使用通配符类型交换Scala中两个数组的元素

我想做如下事情：

class A[T] (_arr: Array[T]) { var arr = _arr }
class C {
  def foo[T <: A[_]](a: Array[T]){
    var ele1 = a(0)
    var ele2 = a(1)
    for(i <- 0 until ele1.arr.length) {
      val temp = ele1.arr(i)
      ele1.arr(i) = ele2.arr(i)
      ele2.arr(i) = temp
    }
  }
}

class A[T] (_arr: Array[T]) { var arr = _arr }
class C {
  def foo[T, B <: A[T]](b: Array[B]){
    var ele1 = b(0)
    var ele2 = b(1)
    for(i <- 0 until ele1.arr.length) {
      val temp = ele1.arr(i)
      ele1.arr(i) = ele2.arr(i)
      ele2.arr(i) = temp
    }
  }
}

我发现以下编译器错误：

<console>:15: error: type mismatch;
 found   : temp.type (with underlying type Any)
 required: _$1
             ele2.arr(i) = temp
                           ^

src/Test.scala:22: error: inferred type arguments [A[Int],Nothing] do not conform to method foo's type parameter bounds [B <: A[T],T]
  (new C).foo(p)
          ^
src/Test.scala:22: error: type mismatch;
 found   : Array[A[Int]]
 required: Array[B]
  (new C).foo(p)
              ^
two errors found

---

src/Test.scala:22:错误：推断的类型参数[A[Int]，Nothing]不符合方法foo的类型参数界限[B我不明白为什么你在这里使用通配符而不是参数化元素类型。你使编译器变得盲目，使它更难确保你做的是明智的事情。特别是，它意识到，由于数组是不变量类型，
ele1.arr（I）
和
ele2.arr（I）
是相同的类型，因此可以被分配。但是当您分配到
temp
时，它意识到它不知道该类型实际上可能是什么，因此它推断出
任何
，当然，这将不适合回到数组中，因为它实际上不是
任何
；它只是不知道它应该是什么

class C {
  def foo[T, B <: A[T]](b: Array[B]){
    var ele1 = b(0)
    var ele2 = b(1)
    for(i <- 0 until ele1.arr.length) {
      val temp = ele1.arr(i)
      ele1.arr(i) = ele2.arr(i)
      ele2.arr(i) = temp
    }
  }
}

C类{
def foo[T，B我不明白你为什么在这里使用通配符而不是参数化元素类型。你使编译器变得盲目，使它更难确保你做的是明智的事情。特别是，它意识到，由于数组是不变量类型，
ele1.arr（I）
和
ele2.arr（I）
是相同的类型，因此可以被分配。但是当您分配到
temp
时，它意识到它不知道该类型实际上可能是什么，因此它推断出
任何
，当然，这将不适合回到数组中，因为它实际上不是
任何
；它只是不知道它应该是什么

class C {
  def foo[T, B <: A[T]](b: Array[B]){
    var ele1 = b(0)
    var ele2 = b(1)
    for(i <- 0 until ele1.arr.length) {
      val temp = ele1.arr(i)
      ele1.arr(i) = ele2.arr(i)
      ele2.arr(i) = temp
    }
  }
}

C类{
德福[T，B据我所知，这两个数组的值的公共超类型返回为任何类型，因为没有任何迹象表明这两个数组共享相同类型的值或具有共同祖先的值。例如，如果ele1.arr是一个数组或整数，ele2.arr是一个“人”数组，它们将如何交换B在数组之间？据我所知，这两个数组的值的公共超类型返回为Any，因为没有任何迹象表明这两个数组共享相同类型的值或具有共同祖先的值。例如，如果ele1.arr是一个数组或整数，而ele2.arr是一个“人”数组，那么它们将如何成为s在数组之间切换？感谢您的回复，这很有帮助，但我在上面做了一个编辑，以演示此实现的用例的问题。非常感谢所有的帮助，如果您知道阅读此内容的好资源或好搜索词，请让我知道。@MatthewSaltz-我不确定如何解决该问题；我希望e类型推断器能够管理，但正如你所看到的，它显然不能。如果你不需要坚持子类型，它会工作，但我不知道如何得到你想要的。非常感谢你的帮助。这很烦人，因为一个看似简单的问题变得非常复杂。我想创建一个类，基本上是一个conta任何类型的数组的iner。然后我想创建另一个类，该类对扩展该类的任何对象进行操作。我缺少什么吗？@MatthewSaltz-我以前从未遇到过这种情况。如果我有机会玩它，也许我会找到让编译器满意的方法，但我不知道我会有机会。谢谢t、 创建一个更简洁的新问题会打破论坛礼节吗？类似于我在前面的评论中所说的内容？感谢您的回复，这很有帮助，但我在上面做了一个编辑，以演示此实现的用例的问题。非常感谢所有的帮助，如果您知道一个好的资源或很好的搜索词来阅读这篇文章，请让我知道。@MatthewSaltz-我不知道如何解决这个问题；我希望类型推断器能够管理，但正如你所看到的，它显然不能。如果你不需要坚持使用子类型，它会起作用，但我不确定如何得到你想要的。非常感谢你的帮助。这是一个非常好的选择N因为一个看似简单的问题变得非常复杂。我想创建一个类，它基本上是任何类型数组的容器。然后我想创建另一个类，对扩展该类的任何对象进行操作。我缺少什么吗？@MatthewSaltz-我以前从未遇到过这个问题。如果我得到一个也许我会找到一个让编译器开心的方法，但我不知道我会有机会。非常感谢。创建一个更简洁的新问题会打破论坛礼仪吗？类似于我在前面的评论中所说的？