这是对泛型类型进行排序的正确方法吗？

Question

我只是想写一个使用泛型的冒泡排序代码。 我不确定这是否是为泛型编写排序逻辑的正确方法。 这里的“if”条件给出了编译时错误。 对于任何特定类型，这都可以正常工作。 我该如何解决这个问题并以更好的方式对其进行编程？ 提前致谢。

def sortAny[T](list: Array[T]): Array[T] = {
var count = 0
while (count < list.length) {
  for (count <- 0 until list.length - 1) {
    if (list(count) > list(count + 1)) {
      val temp = list(count)
      list(count) = list(count + 1)
      list(count + 1) = temp
    }
  }
  count = count + 1
}

list

}

Answer 1

def sortAny[T <% Ordered[T]](list: Array[T]): Array[T] = {
var count = 0
while (count < list.length) {
  for (count <- 0 until list.length - 1) {
    if (list(count) > list(count + 1)) {
      val temp = list(count)
      list(count) = list(count + 1)
      list(count + 1) = temp
    }
  }
  count = count + 1
  }

list
}

Output 将

sortAny: [T](list: Array[T])(implicit evidence$1: T => Ordered[T])Array[T]

T <% S（视图绑定）表示类型 T 必须可转换为 S，因此它必须是 S 的子类型或已定义隐式转换。

Answer 2

添加上下文绑定的答案以确保完整性。 要使用它，需要一个类型 class而不是类型转换，它有一个比较方法，它需要两个T类型的元素。

此处的类型 class表示实现一组功能的模块。 这是 Haskell 等函数式语言中Ad-Hoc 多态性的常见模式，它影响了 Scala 采用它。

Ordered特征在这里不适合作为 class 类型，因为它的比较方法只需要T类型的 1 个元素。 Ordered意味着混入并将this实例与提供的元素T进行比较。 解决方案当然是使用Ordering特征：

  def sortAny[T: Ordering](list: Array[T]): Array[T] = {
    var count = 0
    while (count < list.length) {
      for (count <- 0 until list.length - 1) {
        if (implicitly[Ordering[T]].gt(list(count), list(count + 1))) {
          val temp = list(count)
          list(count) = list(count + 1)
          list(count + 1) = temp
        }
      }
      count = count + 1
    }

    list
  }

这适用于内置类型，因为 Scala 为它们提供了隐式排序：

  sortAny(Array(4, 2, 5, 7, 32, 1213, 32))            // Array(2, 4, 5, 7, 32, 32, 1213)
  sortAny(Array("John", "Helen", "Merry", "Chris"))   // Array(Chris, Helen, John, Merry)

对于自定义类型也是如此，但您必须提供隐式Ordering - 或 - 在自定义类型中混合Ordered特征。 后者之所以有效，是因为：

Ordered 和 Ordering 都提供了隐式允许它们可以互换使用。

Scala 将自动为您的自定义类型创建一个隐式Ordering ，只要它混合在Ordered中。