如何在java中创建2个依赖比较器？

Question

假设我在 Java 中有一个 Product 类和 2 个 Comparators：

1. 第一个是价格Comparator asc 订单。
2. 第二个是价格Comparator desc order。

如果我将第一个更改为产品名称Comparator，那么第二个将自动更改为名称Comparator？

非常感谢！

示例：

class ProductComparatorByPriceDesc implements Comparator<Customer> {
        @Override
        public int compare(Product o1, Product o2) {
             return o1.getPrice() - o2.getPrice();
        }
    }

Class ProductComparatorByPriceAsc implements Comparator<Customer> {
    @Override
    public int compare(Customer o1, Customer o2) {
        return o2.getPrice() - o1.getPrice();
    }
}

因此，如果我将第一个比较器更改为按名称而非价格排序，那么第二个也会更改，但不会相反！

Answer 1

一种方法是：

import java.util.*;

class SomeClass {
  public int price;
  public String name;
  public SomeClass(String name, int price) {
    this.name = name;
    this.price = price;
  }
}

class PriceOrNameComparator implements Comparator<SomeClass> {

  boolean compareByPrice;

  public PriceOrNameComparator byPrice() {
    this.compareByPrice = true;
    return this;
  }

  public PriceOrNameComparator byName() {
    this.compareByPrice = false;
    return this;
  }

  public int compare(SomeClass a, SomeClass b) {
    if (compareByPrice) {
      return a.price - b.price;
    } else {
      return a.name.compareTo(b.name);
    }
  }

  public Comparator<SomeClass> reverseComparator() {
    return new Comparator<SomeClass>() {
      public int compare(SomeClass a, SomeClass b) {
        int res = PriceOrNameComparator.this.compare(a, b);
        if (res == 0) {
          return 0;
        } else {
          return (res > 0) ? -1 : 1;
        }
      }
    };
  }
}

class Test {
  public static void main(String[] args) {
    SomeClass s1 = new SomeClass("a", 5);
    SomeClass s2 = new SomeClass("b", 4);
    PriceOrNameComparator c = new PriceOrNameComparator().byPrice();
    Comparator<SomeClass> r = c.reverseComparator();
    System.out.println(c.compare(s1, s2)); // 1
    System.out.println(r.compare(s1, s2)); // -1
    c.byName();
    System.out.println(c.compare(s1, s2)); // -1
    System.out.println(r.compare(s1, s2)); // 1
  }
}

基本上，外部比较器是可配置的，内部的倒序比较器是一个匿名的内部类，对外部比较器有一个隐式引用，并且可以观察其状态的变化。

Answer 2

我建议只使用一个比较器类来按价格进行比较，并使用一个单独的比较器类来按名称进行比较（或者没有类 - 请参阅我的答案的结尾）。每个班级都做一件事，而且做得很好。

然后您可以使用Comparator.reversed 默认方法反转任何 比较器...同样您可以使用Comparator.thenComparing 将它们链接在一起，如果您希望按名称和价格订购，则为示例：

Comparator<Product> nameThenPrice =
    new NameComparator().thenComparing(new PriceComparator());

（如果您不使用 Java 8，编写一个 ReversingComparator 和一个 CompoundComparator 使用现有的两个是很容易的。）

您还可以在Comparator 中使用Java 8 的静态方法：

Comparator<Product> byName = Comparator.comparing(p -> p.getName());
Comparator<Product> byPrice = Comparator.comparing(p -> p.getPrice());
Comparator<Product> nameThenPrice = byName.thenComparing(byPrice);

这样您通常根本不需要手动实现Comparator。