在 Java 中结合可变参数和泛型进行链式比较
Combining varargs and generics for chained comparisons in Java
这里有一个棘手的问题。我在同时使用可变参数和泛型之间存在冲突。以下给出的代码:
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 接口函数的可变参数。所以首先我写了这样的方法:
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;
}
但我没有考虑到在这种情况下,对于可变参数数组中的所有 Function<T, C>
比较,通用类型 C 必须是同一类型。正如您在上面看到的,我想使用不同的 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;
}
此处 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);
}
与其使用 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)
or the primitive specialization comparingInt
.
构造 Comparator
个对象来使用它
@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);
}
这里有一个棘手的问题。我在同时使用可变参数和泛型之间存在冲突。以下给出的代码:
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 接口函数的可变参数。所以首先我写了这样的方法:
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;
}
但我没有考虑到在这种情况下,对于可变参数数组中的所有 Function<T, C>
比较,通用类型 C 必须是同一类型。正如您在上面看到的,我想使用不同的 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;
}
此处 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);
}
与其使用 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)
or the primitive specialization comparingInt
.
Comparator
个对象来使用它
@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);
}