java - 通用深度比较等于

Question

基本上我不想比较元素，而是比较你包含的元素。如果下面的内容能起作用，那就太酷了，但事实并非如此。

public boolean equals(Ie<T> that) {
    T This = this.value;
    T That = that.value;
    boolean x = That.compareTo(This) == 0;
    return x;
}

我所做的是:

public boolean equals(Object obj) {
    if (obj == null)
        return false;

    String tmp = obj.toString();
    if (this.value instanceof Integer)
        return equalsInt(new Ie<Integer>(Integer.parseInt(tmp)));
    // etc.

    return false;
}

public boolean equalsInt(Ie<Integer> ie) {
    Integer This = this.value.intValue();
    Integer That = ie.value;
    boolean x = That.compareTo(This) == 0;
    return x;
}

这是一个明显的暴力解决方案。可以不用 obj.toString(); + new 元素来完成吗？

编辑:

Ie 类定义为:

public static class Ie<T extends Number & Comparable<? super T>>
        extends Number implements Comparable<Ie<T>> {

类与方法相比相当简单:

public int compareTo(Ie<T> that) {
    T This = this.value;
    T That = that.value;
    return (This.compareTo(That) < 0 ? -1 : (This
            .compareTo(That) > 0 ? 1 : 0));
}

我正在 Collection addall 方法中使用该类，其中 contains 正在调用 equals。

埃里克森解决方案运行良好:

@Override
public boolean equals(Object that) {
    if (that == null)
        return false;
    if (this == that)
        return true;
    if (that instanceof Ie<?>) {
        Object ThisValue = this.value;
        Object ThatValue = ((Ie<?>) that).value;
        return ThisValue.equals(ThatValue);
    }

    return false;
}

Answer 1

为此，每个类型 T 都必须实现 Comparable 接口(interface)，并且每个实现 Comparable 的类都应该实现 equals 以一致的方式。所以，Matt Ball's答案应该足够了。

但是，如果由于某种原因不能实现，则需要一个解决 Java 类型删除问题的解决方案。通过显式指定T的类型，可以完成必要的类型检查。 Ie 类可以部分定义如下:

class Ie<T extends Comparable<T>>
{

  private final Class<? extends T> type;

  private final T value;

  public Ie(Class<? extends T> type, T value)
  {
    this.type = type;
    this.value = value;
  }

  @Override
  public boolean equals(Object obj)
  {
    if (obj == this)
      return true;
    if (obj instanceof Ie) {
      Object that = ((Ie<?>) obj).value;
      if (type.isInstance(that)) {
        return value.compareTo(type.cast(that)) == 0;
      }
    }
    return false;
  }

}