在Java中结合varargs和泛型进行链式比较

这是一个棘手的问题。同时使用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);
    }
}

lambda是Java8接口函数的vararg。所以首先我写了这样的方法：

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;
}

---

使用

比较器比使用
比较器更容易，而不是使用
可比比较器
：

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;
}

然后，您可以通过使用或原语专门化构造
比较器
对象来使用它


通过这种方法，您甚至可以质疑这种效用的存在，并简单地

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

@覆盖
公共内部比较（MyObject o）{
返回比较器比较（对象->对象名称）
.然后比较（对象->对象索引）
.比较（这个，o）；
}
这是一个很好的方法。如果我不必为每个条件分别编写Comparator.comparating（），那就更好了。由于comparison（）还接受一个函数，因此在chainedCompare方法中保持函数varargs并构造比较器是很酷的。但我想我会遇到和以前一样的一般问题，对吗？这是不能解决的吗？@Arceus是的，你也会遇到同样的问题。请注意，我用另一个简单的解决方案进行了编辑。事实上，您的建议是可能的解决方案。谢谢你。但我真正的问题不仅仅是把比较的内容做成一行，而且要尽可能简短。老实说，我发现您的代码有点冗长，因为我必须在每个被覆盖的compareTo（将有很多）中这样编写代码。
@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);
}

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;
}

@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);
}

@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);
}