结合varargs和泛型用于Java中的链式比较

Question

这是一个难以破解的坚果.我在使用varargs和泛型之间发生了冲突.给定代码:

public class MyObject implements Comparable<MyObject>
{
    private String name;
    private int index;

    @Override
    public int compareTo(MyObject o)
    {
        if (name.compareTo(o.name) != 0)
            return name.compareTo(o.name);
        return ((Integer) index).compareTo(o.index);
    }
}

我希望该compareTo方法使用多个比较条件.如果字符串相同,则使用ints代替.通常情况我会说.
我希望创建一个静态方法来处理这个问题.我希望chainedCompare像这样调用新方法:

public int compareTo(MyObject o)
{
    return chainedCompare(this, o, myO -> myO.name, myO -> myO.index);
}

lambdas是Java 8接口函数的变量.所以首先我写了这样的方法:

public static <T, C extends Comparable<C>> int chainedCompare(T object1, T object2, Function<T, C>... comparisons)
{
    int compareValue = 0;
    for (Function<T, C> comparison : comparisons)
    {
        compareValue = comparison.apply(object1).compareTo(comparison.apply(object2));
        if (compareValue != 0)
            break;
    }
    return compareValue;
}

但我不认为在这种情况下,泛型类型C必须Function<T, C>与varargs数组中的所有比较相同.如您所见,我想使用不同的可比较对象(例如示例中的String和Integer).
然后我将其修改为此版本:

public static <T> int chainedCompare(T object1, T object2, Function<T, ? extends Comparable<?>>... comparisons)
{
    int compareValue = 0;
    for (Function<T, ? extends Comparable<?>> comparison : comparisons)
    {
        compareValue = comparison.apply(object1).compareTo(comparison.apply(object2));
        if (compareValue != 0)
            break;
    }
    return compareValue;
}

C类在这里被替换为通配符.虽然方法调用现在可以工作,但是方法本身不能编译,因为通配符的类型参数为compareTo.

所以一方面我需要一个固定的泛型类型(扩展Comparable)用于Function接口,但另一方面我需要不同(第二)泛型类型的Function接口,你通常可以设置一个通配符.怎么解决这个？
我唯一的要求是我可以像使用未定义数量的比较条件一样简单地调用静态方法.

---

根据Tunaki的建议,我能够修改如下方法,可以按需使用:

@SuppressWarnings("raw-types")
public static <T> int chainedCompare(T object1, T object2, Function<T, ? extends Comparable>... comparisons)
{
    return Arrays.stream(comparisons)
        .map(Comparator::comparing)
        .reduce(Comparator::thenComparing)
        .map(c -> c.compare(object1, object2))
        .orElse(0);
}

public int compareTo(MyObject o)
{
    return chainedCompare(this, o, myO -> myO.name, myO -> myO.index);
}

Answer 1

不使用 a Comparable，使用 a 会更容易Comparator：

public static <T> int chainedCompare(T object1, T object2, Comparator<T>... comparators) {
    int compareValue = 0;
    for (Comparator<? super T> comparator : comparators) {
        compareValue = comparator.compare(object1, object2);
        if (compareValue != 0)
            break;
    }
    return compareValue;
}

您还可以使用并将所有比较器链接thenComparing在一起

@SafeVarargs
public static <T> int chainedCompare(T object1, T object2, Comparator<T>... comparators) {
    return Arrays.stream(comparators)
                 .reduce(Comparator::thenComparing)
                 .map(c -> c.compare(object1, object2))
                 .orElse(0);
}

然后您可以通过使用或 原始特化构造Comparator对象来使用它。comparing(keyExtractor)comparingInt

@Override
public int compareTo(MyObject o) {
    return chainedCompare(this, o,
             Comparator.comparing(obj -> obj.name),
             Comparator.comparingInt(obj -> obj.index)
           );
}

通过这种方法，您甚至可以质疑这种实用程序的存在性，并且只需简单地了解一下

@Override
public int compareTo(MyObject o) {
    return Comparator.<MyObject, String> comparing(obj -> obj.name)
                     .thenComparingInt(obj -> obj.index)
                     .compare(this, o);
}