泛型类型变量的局部类型推断与逆变性技术咨询

Great question! Let's break this down clearly—starting with how local variable type inference (LVTI) works in your rewrite, then unpacking the contravariance details tied to your generic method.

First, here's how you can rewrite your method using var to leverage LVTI, while preserving all the original functionality:

public static <T> Set<T> distinct(Collection<? extends T> list, Comparator<? super T> comparator) {
    var set = new TreeSet<>(comparator); // LVTI infers TreeSet<T> automatically
    set.addAll(list);
    return set;
}

The compiler has no trouble inferring that set should be of type TreeSet<T> here. Why? Because:

• The TreeSet constructor accepts a Comparator<? super E>, where E is the type of elements in the set.
• Your method's comparator parameter is typed as Comparator<? super T>, and you're adding elements from Collection<? extends T> to the set. The compiler ties these constraints together to deduce that E must be T, so var resolves to TreeSet<T>—which is perfectly compatible with the return type Set<T>.

Let's dive into the contravariance aspect of your original method's Comparator<? super T> parameter:

• Contravariance (using ? super T) allows your method to accept any comparator that can handle T or its parent types. This makes the method far more flexible: for example, if T is String, you could pass a Comparator<Object> (since Object is a supertype of String, and the comparator's compare method can accept String instances via polymorphism).
• When using LVTI, this contravariance is fully respected. The compiler doesn't lose track of the ? super T constraint on the comparator—it uses it to validate that the comparator is compatible with the inferred TreeSet<T> type. Since TreeSet<T> expects a Comparator<? super T>, your input parameter fits perfectly.

• You don't need to explicitly specify the type parameter for TreeSet (like new TreeSet<T>(comparator)) when using var—the compiler's inference is reliable here, thanks to the constraints from both the list and comparator parameters.
• If you ever run into edge cases where type inference is ambiguous (rare here), you can always fall back to explicitly specifying the type parameter, but that's unnecessary for your current method.
• The original method's use of Collection<? extends T> (covariance) pairs nicely with the contravariant comparator: it lets you pass any collection of T subtypes (like ArrayList<String> when T is CharSequence), while the comparator can handle the supertype of T.

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