Arrays.sort方法中的泛型边界不兼容问题解析

先看以下代码示例：

String[] strings = new String[10];
// 填充strings数组
Arrays.sort(strings, Comparator.naturalOrder());
Arrays.sort(strings, Comparator.reverseOrder());
Arrays.sort(strings, Comparator.naturalOrder().reversed());          // 编译错误
Arrays.sort(strings, Comparator.<String>naturalOrder().reversed());

Arrays.sort的泛型方法签名为：

<T> void sort(T[] a, Comparator<? super T> c);

要求传入T[]类型的数组，以及Comparator<? super T>类型的比较器。

编译错误详情 #

第三个调用出现编译错误，IDE提示：

no instance(s) of type variable(s) exist so that String conforms to T

编译期类型推断的错误信息为：

inference variable T has incompatible bounds
 lower bounds: T,java.lang.Object
 lower bounds: java.lang.String

涉及的Comparator方法泛型约束 #

要理解问题，先明确三个核心方法的泛型差异：

// naturalOrder：泛型T必须实现Comparable<? super T>
<T extends Comparable<? super T>> Comparator<T> naturalOrder() {}
// reverseOrder：同naturalOrder，T必须实现Comparable<? super T>
<T extends Comparable<? super T>> Comparator<T> reverseOrder() {}
// reversed：无额外泛型约束，直接返回Comparator<T>
Comparator<T> reversed() {}

1. 不兼容边界问题的解释 #

当调用Comparator.naturalOrder().reversed()时，编译器的类型推断链出现了冲突：

1. 对于Arrays.sort(strings, ...)，由于数组是String[]，编译器会推断泛型参数T为String，要求比较器类型为Comparator<? super String>。
2. 对于naturalOrder().reversed()的调用链，编译器需要先确定naturalOrder()的泛型参数：
   • 如果没有显式指定，编译器会尝试找一个满足naturalOrder()约束（T extends Comparable<? super T>）的类型，同时让reversed()返回的Comparator<T>适配Comparator<? super String>。
   • 理论上能适配Comparator<? super String>的T需要是String的父类，但String的唯一父类是Object，而Object并没有实现Comparable接口，不满足naturalOrder()的约束。
3. 此时编译器找不到一个同时满足所有约束的泛型类型T，就会抛出“不兼容边界”的错误——既要求T是String（来自数组的T[]），又要求T是Object（来自比较器的? super T），还要求T实现Comparable，三者无法同时满足。

2. 仅第三个示例报错的原因及约束生效逻辑 #

逐个分析四个调用的类型推断过程：

• 第一个调用Arrays.sort(strings, Comparator.naturalOrder())：
  编译器直接根据Arrays.sort的参数上下文，将naturalOrder()的泛型参数推断为String。String实现了Comparable<String>，完全满足naturalOrder()的约束，返回的Comparator<String>也适配Comparator<? super String>，编译通过。
• 第二个调用Arrays.sort(strings, Comparator.reverseOrder())：
  逻辑和第一个调用一致，reverseOrder()的泛型参数被推断为String，满足约束且返回类型适配，编译通过。
• 第三个调用Arrays.sort(strings, Comparator.naturalOrder().reversed())：
  调用链分为两步：先调用naturalOrder()，再调用reversed()。由于reversed()没有泛型约束，编译器无法从reversed()的返回值上下文反推naturalOrder()的T必须是String。它会尝试推断一个最宽泛的类型（Object），但Object不满足naturalOrder()的约束；同时即使忽略这个，reversed()返回的Comparator<Object>也无法和Arrays.sort要求的Comparator<? super String>完成合法的类型推断绑定，最终导致编译失败。
• 第四个调用Arrays.sort(strings, Comparator.<String>naturalOrder().reversed())：
  显式指定了naturalOrder()的泛型参数为String，因此naturalOrder()返回Comparator<String>，调用reversed()后得到的Comparator<String>完全适配Arrays.sort要求的Comparator<? super String>，编译通过。

简单来说：前两个调用的泛型推断直接绑定到String，满足约束；第三个调用因为中间的reversed()无约束，导致推断链断裂；第四个调用通过显式指定泛型参数，直接锁定了合法的类型。

内容的提问来源于stack exchange，提问作者MeYokYang