我一直在阅读 Scala 中的类型类，并认为我已经很好地掌握了它，直到我想起了 Java 的 java.util.Comparator。

如果我理解正确的话，Ordering 是类型类的原型(prototype)示例。我能想到的 Comparator 和 Ordering 实例之间的唯一区别是比较器必须是显式的，而排序可以而且通常是隐式的。

Comparator 是类型类吗？我得到(错误的？)印象，即 Java 实际上没有类型类。这是否意味着类型类需要能够是隐式的？我认为类型类的隐式转换主要是语法糖 - 尽管它很棒，但它“只是”给了编译器足够的提示 - 我是不是遗漏了什么？

下面的代码示例展示了 Comparator 如何向没有排序操作的类型添加排序操作，而无需修改所述类型。

// Comparator used to retroactively fit the MyExample class with an ordering operation.
public static class MyExampleComparator implements Comparator<MyExample> {
    public static final Comparator<MyExample> SINGLETON = new MyExampleComparator();

    private MyExampleComparator() {}

    public int compare(MyExample a, MyExample b) {
        return a.value - b.value;
    }
}

// Custom type, its only purpose is to show that Comparator can add an ordering operation to it when it doesn't
// have one to begin with.
public static class MyExample {
    private final int value;

    public MyExample(int v) {
        value = v;
    }

    public String toString() {
        return Integer.toString(value);
    }
}

public static void main(String... args) {
    List<MyExample> list = new ArrayList<MyExample>();

    for(int i = 0; i < 10; i++)
        list.add(new MyExample(-i));

    // Sorts the list without having had to modify MyExample to implement an interface.
    Collections.sort(list, MyExampleComparator.SINGLETON);

    // Prints the expected [-9, -8, -7, -6, -5, -4, -3, -2, -1, 0]
    System.out.println(list);
}

最佳答案

我不想专门谈论类型类，而是谈论 Scala 中的类型类模式；原因是，当您开始询问“什么是类型类”时，您最终得出的结论是它只是以特定方式使用的接口(interface)。

(在 Haskell 中，call a specific construct a type class 更有意义。)

类型类模式由三个基本部分组成(但为了方便通常还有几个部分)。第一个是由单一类型参数化的接口(interface)，它抽象了参数化类型的某种能力。 java.util.Comparator 是一个完美的例子:它提供了一个用于比较的接口(interface)。让我们使用它。

您需要的第二件事是使用该参数化的方法，您可以在 Scala 中使用简写符号指定它:

// Short signature
//             v------------------- "We must be able to find a Comparator for A"
def ordered[A: java.util.Comparator](a0: A, a1: A, a2: A) = {
  val cmp = implicitly[java.util.Comparator[A]]   // This is the Comparator
  cmp.compare(a0, a1) <= 0 && cmp.compare(a1, a2) <= 0
}

// Long signature version
def ordered[A](a0: A, a1: A, a2: A)(implicit cmp: java.util.Comparator[A]) = {
  cmp.compare(a0, a1) <= 0 && cmp.compare(a1, a2) <= 0
}

好的，但是你从哪里得到比较器？这是第三个必要的部分。默认情况下，Scala 不会为您可能喜欢的类提供 Comparator，但您可以定义自己的:

implicit object IntComp extends java.util.Comparator[Int] {
  def compare(a: Int, b: Int) = a.compareTo(b)
}

scala> ordered(1,2,3)
res5: Boolean = true

scala> ordered(1,3,2)
res6: Boolean = false

现在您已经为 Int 提供了功能(隐式)，编译器会将隐式参数填充到 ordered 以使其工作。如果您还没有提供该功能，它会报错:

scala> ordered("fish","wish","dish")
<console>:12: error: could not find implicit value
for parameter cmp: java.util.Comparator[String]
          ordered("fish","wish","dish")

直到您提供该功能:

implicit object StringComp extends java.util.Comparator[String] {
  def compare(a: String, b: String) = a.compareTo(b)
}

scala> ordered("fish","wish","dish")
res11: Boolean = false

那么，我们称java.util.Comparator 为类型类吗？它的功能肯定与处理类型类模式的等效部分的 Scala 特性一样好。因此，即使类型类模式在 Java 中效果不佳(因为您必须显式指定要使用的实例，而不是隐式查找它)，从 Scala 的角度来看 java.util.Comparator 是一个类型类。

关于java - Comparator 是类型类吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/19500176/