这是一个棘手的问题。我在同时使用可变参数和泛型之间存在冲突。按照给定的代码:

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使用多个比较条件的方法。如果字符串相同，则改用整数。我会说通常情况。
我很想创建一个静态方法来一般地处理这个问题。我想要新方法 chainedCompare像这样调用:

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

lambda 是 Java 8 接口(interface)函数的可变参数。所以首先我写了这样的方法:

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 数组中的比较。正如您在上面看到的，我想使用不同的 Comparables(例如示例中的 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;
}

Type C 在这里用通配符代替。虽然方法调用现在可以工作，但由于 compareTo 的通配符类型参数，方法本身无法编译。 .

因此，一方面我需要一个固定的通用类型(扩展 Comparable)用于 Function 接口(interface)，但另一方面我需要不同(第二)通用类型的 Function 接口(interface)，您通常可以在其中设置通配符。如何解决？
我唯一的要求是我可以调用静态方法，就像在未定义数量的比较条件下显示的那样简单。

根据 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);
}

最佳答案

与其使用Comparable，不如使用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);
}

然后您可以通过使用 comparing(keyExtractor) 构建 Comparator 对象来使用它或原始专业 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);
}

关于java - 结合可变参数和泛型以在 Java 中进行链式比较，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35916874/