使用 ComparisonChain 相对于 Objects.equal() && 有什么好处？ Objects.equal() ...与番石榴

Question

我刚刚开始使用谷歌的番石榴集合（ComparisonChain和对象）。在我的 pojo 中，我重写了 equals 方法，所以我首先这样做了：

return ComparisonChain.start()
         .compare(this.id, other.id)
         .result() == 0;

但是，我随后意识到我也可以使用这个：

return Objects.equal(this.id, other.id);

：

return Objects.equal(this.name, other.name) 
       && Objects.equal(this.number, other.number);

而且我看不到比较链何时会更好，因为您可以轻松添加进一步的条件，如下所示 唯一的好处是我可以看看你是否特别需要返回一个 int 。它有两个额外的方法调用（start 和 result），对于菜鸟来说更复杂。

我缺少的ComparisonChain 是否有明显的好处？

（是的，我还使用适当的 Objects.hashcode() 覆盖 hashcode）

Answer 1

ComparisonChain 允许您通过比较多个属性（例如按多列对网格进行排序）来检查一个对象是否小于或大于另一个对象。
它应该在实现Comparable或Comparator时使用。

Objects.equal 只能检查是否相等。

Answer 2

ComparisonChain 旨在帮助对象实现 Comparable 或 Comparator 接口。

如果您只是实现 Object.equals()，那么您是对的； Objects.equal 就是您所需要的。但是，如果您尝试正确地实现 Comparable 或 Comparator，那么使用 ComparisonChain 会比其他方式容易得多。

考虑一下：

class Foo implements Comparable<Foo> {
   final String field1;
   final int field2;
   final String field3;

   public boolean equals(@Nullable Object o) {
      if (o instanceof Foo) {
         Foo other = (Foo) o;
         return Objects.equal(field1, other.field1)
             && field2 == other.field2
             && Objects.equal(field3, other.field3);
      }
      return false;
   }

   public int compareTo(Foo other) {
      return ComparisonChain.start()
         .compare(field1, other.field1)
         .compare(field2, other.field2)
         .compare(field3, other.field3)
         .result();
   }
 }

与实现compareTo相反

 int result = field1.compareTo(other.field2);
 if (result == 0) {
   result = Ints.compare(field2, other.field2);
 }
 if (result == 0) {
   result = field3.compareTo(other.field3);
 }
 return result;

...更不用说正确执行该操作的技巧了，这比您想象的要高。 （我见过比你想象的更多搞乱compareTo的方法。）

Answer 3

使用 Guava 的 ComparisonChain 时要小心，因为它会为每个比较的元素创建一个实例，因此您将看到创建的 N x Log N 比较链只是为了如果您正在排序，则比较；如果您正在迭代并检查相等性，则比较 N 个实例。

Java 8 的示例：

import java.util.Comparator;
import static java.util.Comparator.naturalOrder;
import static java.util.Comparator.nullsLast;

private static final Comparator<DomainObject> COMPARATOR=Comparator
  .comparingInt(DomainObject::getId)
  .thenComparing(DomainObject::getName,nullsLast(naturalOrder()));

@Override
public int compareTo(@NotNull DomainObject other) {
  return COMPARATOR.compare(this,other);
}

如果可能的话，我会使用最新的 Java 8 API 或 Guava 的 Ordering API 创建一个静态 Comparator ，它允许您执行此操作，这里是 如何使用 Guava 的 Ordering API：https://github.com/google/guava/wiki/OrderingExplained

Answer 4

在 POJO 中重写方法的上下文中，我想到了一些 Guava 的工具与一些标准方法相匹配。

• Object.equals 使用 Objects.equals 进行处理，大致与您提到的
• Object.hashCode 使用 Objects.hashCode like return Objects.hashCode(id, name);

• Comparable.compareTo 使用 ComparisonChain 处理，如下所示：

  public intcompareTo(Chimpsky chimpsky) {
      返回ComparisonChain.start()
          .compare(this.getId(), chimpsky.getId())
          .compare(this.getName(), chimpsky.getName())
          。结果（）;
  }