5

Bloch 的精彩著作《Effective Java》指出，如果equals不是对称的，那么集合的行为contains是不确定的。

在他给出的示例中（在下面稍作修改后复制），布洛赫说他看到了“假”，但也可以看到真或异常。

如果标准未指定是否contains(Object o)检查e.equals(o)或o.equals(e)针对集合中的每个项目，您可能会看到“true”，并且前者已实施。但是，Collections Javadoc明确指出它必须是后者（这就是我观察到的）。

因此，我看到的唯一可能性是“错误”或可能是异常（但String Javadoc似乎排除了后者）。

我理解更广泛的观点，不对称很可能equals会导致集合之外的代码出现问题，但我没有看到他引用的示例。

我错过了什么吗？

import java.util.List;
import java.util.ArrayList;

class CIString {
  private final String s;

  public CIString(String s) {
    this.s = s;
  }

  @Override public boolean equals( Object o ) {
    System.out.println("Calling CIString.equals from " + this.s );
    if ( o instanceof CIString) 
      return s.equalsIgnoreCase( ( (CIString) o).s);
    if ( o instanceof String) 
      return s.equalsIgnoreCase( (String) o );
    return false;
  }
  // Always override hashCode when you override equals
  // This is an awful hash function (everything collides -> performance is terrible!)
  // but it is semantically sound.  See Item 10 from Effective Java for more details.
  @Override public int hashCode() { return 42; }
}

public class CIS {
  public static void main(String[] args) {
   CIString a = new CIString("Polish");
   String s = "polish";

   List<CIString> list = new ArrayList<CIString>();
   list.add(a);
   System.out.println("list contains s:" + list.contains(s));
 }
}
4

2 回答 2

3

现在是清晨，所以也许我错过了您问题的真正意义，此代码将失败：

public class CIS 
{
    public static void main(String[] args) 
    {
        CIString a = new CIString("Polish");
        String s = "polish";

        List<String> list = new ArrayList<String>();
        list.add(s);
        System.out.println("list contains a:" + list.contains(a));
    }
}

至少奇怪的是您的代码找到它而我的代码没有（从理智的角度来看，这显然不是您的代码的编写方式:-)

编辑：

public class CIS {
  public static void main(String[] args) {
   CIString a = new CIString("Polish");
   String s = "polish";

   List<CIString> list = new ArrayList<CIString>();
   list.add(a);
   System.out.println("list contains s:" + list.contains(s));

   List<String> list2 = new ArrayList<String>();
   list2.add(s);
   System.out.println("list contains a:" + list2.contains(a));
 }
}

现在代码打印出来：

list contains s:false
Calling CIString.equals from Polish
list contains a:true

这仍然没有意义......而且非常脆弱。如果两个对象像 a.equals(b) 一样相等，那么它们也必须像 b.equal(a) 一样相等，但您的代码并非如此。

从javadoc：

它是对称的：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应该返回 true。

所以，是的，书中的例子可能与集合API的Javadoc相反，但原理是正确的。不应该创建行为奇怪的 equals 方法，否则最终会出现问题。

编辑2：

正文的重点是：

在 Sun 当前的实现中，它恰好返回 false，但这只是一个实现工件。在另一个实现中，它可以很容易地返回 true 或抛出运行时异常。一旦你违反了 equals 契约，你根本不知道其他对象在面对你的对象时会如何表现。

但是，鉴于 Javadoc 所说的内容，似乎该行为是固定的，而不是实现工件。

如果它不在 javadoc 中，或者如果 javadoc 不是规范的一部分，那么它可能会在以后发生更改，并且代码将不再工作。

于 2011-09-22T14:25:15.593 回答
1

在我现在看的这本书（第 2 版）中，项目编号为 8，关于对称性要求的整个部分呈现得非常糟糕。

您提到的特定问题似乎是由使用代码太接近实现引起的，从而掩盖了作者试图提出的观点。我的意思是，我list.contains(s)通过它看到了 ArrayList 和 String，所有关于返回 true 或抛出异常的推理对我来说都是零意义的，真的。

  • 我不得不将“使用代码”从实现中移开，以了解它可能是怎样的：

    void test(List<CIString> list, Object s) {
    if (list != null && list.size() > 0) {
        if (list.get(0).equals(s)) { // unsymmetric equality in CIString
            assert !list.contains(s); // "usage code": list.contain(s)
        }
    }
}

上面看起来很奇怪，但只要list是我们的 ArrayList 并且s是我们的 String，测试就通过了。

现在，如果我们使用其他东西而不是 String 会发生什么？比如说，如果我们new CIString("polish")作为第二个参数传递会发生什么？

看，尽管通过了第一次equals检查，但断言在下一行失败——因为 contains 将为这个对象返回 true。

类似的推理适用于 Bloch 提到异常的部分。这一次，我将第二个参数保留为 String，但对于第一个参数，想象一个 List 实现而不是 ArrayList（这不是合法的）。

  • 你看，List 实现通常被允许从 中抛出 ClassCastException contains，我们只需要得到一个可以完全做到这一点的实现并将其用于我们的测试。想到的一个可能是基于TreeSet，它使用适当的比较器包裹在我们的原始列表中。

    List<CIString> wrapperWithCce(List<CIString> original,
        Comparator<CIString> comparator) {
    final TreeSet<CIString> treeSet = new TreeSet<CIString>(comparator);
    treeSet.addAll(original);
    return new ArrayList<CIString>() {
        { addAll(treeSet); }
        @Override
        public boolean contains(Object o) {
            return treeSet.contains(o); // if o is String, will throw CCE
        }
    };
}

如果我们将上面的列表和字符串“polish”传递给会发生什么test？list.get(0).equals(s)仍然会通过检查，但会从TreeSet.contains()list.contains(s)抛出 ClassCastException 。

这似乎就像 Bloch 在提到list.contains(s)可能引发异常时所想到的情况 - 再次，尽管通过了 first equalscheck。

于 2011-09-23T07:22:40.763 回答