具有可变数量的方法引用的通用对象比较方法用于比较

Question

我经常需要比较某种类型的实例是否相等，但我不需要比较所有的东西，只需要比较某些字段。我通常这样做：

Comparator<SomeType> c = Comparator.comparing(SomeType::getNumber)
  .thenComparing(SomeType::getType)
  .thenComparing(SomeType::getSite)
  .thenComparing(SomeType::getAddition)
  .thenComparing(SomeType::getImportantFlag);

if (c.compare(old, new) == 0) {
...
}

因为我必须经常这样做，所以我想知道是否有一种通用的方法可以做到这一点。
我必须比较的所有对象都扩展了某个基础 class。有没有办法编写一个静态方法来为我做所有这些比较？我在考虑一个静态方法，它必须为要比较的对象提供参数，并为所有方法引用提供一个可变参数：

public static <T extends BaseType> boolean areFieldsEqual(T left, T right, whatShouldIPutHere... fields) {
}

但我不知道如何传递方法引用以及如何在方法内的比较器中使用它们。这可以通过某种方式完成还是我应该尝试其他方法？

Answer 1

我想出了一些似乎可行的方法：

public static <T extends BaseType> boolean areFieldsEqual(T left, T right, Function<T,? extends Comparable>... fields)
{
    if (fields.length < 1) {
        return true;
    }
    Comparator<T> c = Comparator.comparing(fields[0]);
    for (int i = 1; i < fields.length; i++) {
        c = c.thenComparing (fields[i]);
    }
    return c.compare(left, right) == 0;
}

测试类:

class BaseType {
    String x;
    int y;
    public BaseType (String x, int y) {
        this.x=x;
        this.y=y;
    }
    String getX () {return x;}
    int getY () { return y;}
}

class SubType extends BaseType {
    String z;

    public SubType (String x, int y,String z) {
        super(x,y);
        this.z=z;
    }
    String getZ () {return z;}
}

用法：

BaseType one = new BaseType("some",1);
BaseType two = new BaseType("some",2);
SubType three = new SubType("some",1,"else");
SubType four = new SubType("some",2,"else");
System.out.println (areFieldsEqual(one,two,BaseType::getX,BaseType::getY));
System.out.println (areFieldsEqual(three,four,SubType::getZ,BaseType::getX));

输出：

false
true

Answer 2

将 varargs 与泛型一起使用将导致编译器警告，如 Potential heap pollution via varargs parameter。通常为了避免这样的事情，我们可以提供如下几个功能：

单字段：

public static <T extends BaseType> boolean areFieldsEqual(
  T first, T second, Function<? super T, ? extends Comparable> keyExtractor) {
    Comparator<T> comp = Comparator.comparing(keyExtractor);
    return comp.compare(first, second) == 0;
}

有两个字段：

public static <T extends BaseType> boolean areFieldsEqual(
      T first, T second, Function<T, ? extends Comparable> firstField,
      Function<T, ? extends Comparable> secondField) {
    Comparator<T> comp = Comparator.comparing(firstField).thenComparing(secondField);
    return comp.compare(first, second) == 0;
}

使用 varargs。由于我们没有存储 fields 中的任何内容，因此我们可以在该方法上使用 @SafeVarargs：

@SafeVarargs
public static <T extends BaseType> boolean areFieldsEqual(
  T first, T second, Function<T, ? extends Comparable>... fields) {
    if (fields.length < 1) {
      return true;
    }
    Comparator<T> comp = Comparator.comparing(fields[0]);
    for (int i = 1; i < fields.length; i++) {
      comp = comp.thenComparing(fields[i]);
    }
    return comp.compare(first, second) == 0;
}

Answer 3

以下是您可以使用的基本思路：

List<Function<SomeType, Comparable>> fieldsToTest = new ArrayList<>();
fieldsToTest.add(SomeType::getType);
fieldsToTest.add(SomeType::getSite);
System.out.println(areFieldsEqual(new SomeType(...), new SomeType(...), fieldsToTest));

areFieldsEqual方法实现：

static <T extends BaseType> boolean areFieldsEqual(T left, T right, 
                                                   List<Function<T, Comparable>> fields) {
    Comparator<T> c = fields.stream().reduce(
        (l, r) -> 0, Comparator::thenComparing, Comparator::thenComparing);
    return c.compare(left, right) == 0;
}

或者，如果您想坚持使用 varargs 参数：

static <T extends BaseType> boolean areFieldsEqual(T left, T right,
                                                   Function<T, Comparable>... fields) {
    Comparator<T> c = Arrays.stream(fields).reduce(
        (l, r) -> 0, Comparator::thenComparing, Comparator::thenComparing);
    return c.compare(left, right) == 0;
}

具有可变数量的方法引用的通用对象比较方法用于比较

Generic object comparison method with a variable number of method references for comparison

java

generics

comparator