覆盖"等于"方法:如何确定参数的类型？

Question

我正在尝试覆盖equals参数化类的方法.

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (!(obj instanceof Tuple))
        return false;

    Tuple<E> other = (Tuple<E>) obj; //unchecked cast
    if (!a0.equals(other.a0) && !a0.equals(other.a1)) {
        return false;
    }
    if (!a1.equals(other.a1) && !a1.equals(other.a0)) {
        return false;
    }

    return true;
}

我怎样才能确保<E>该的other对象是一样的this？

Answer 1

您可以通过保留对Class<E>类型的引用来完成此操作.但是,在我看来,相等测试应该是对象所代表的值,而不是值表达的具体类型.

一个典型的例子就是Collections API. new ArrayList<String>().equals(new LinkedList<Object>())回报true.虽然它们具有完全不同的类型,但它们代表相同的值,即"空集合".

就个人而言,两个Tuple代表相同数据(例如("a", "b"))的s 应该不相等,因为一个是类型Tuple<String>而另一个是Tuple<Object>？

Answer 2

因为擦除你不能。您能做的最好的事情是将您计划在“java.lang.Class”字段成员中保存的元组类型存储在元组类中。然后您可以比较这些字段以确保元组类拥有相同的类型。

另请参阅此线程： Java 中 C++ Pair<L,R> 的等价物是什么？

如果您发布更多关于您的课程的信息会有所帮助。我在想未经检查的演员表和你等同的字段数意味着它应该是 Tuple<E,F> 否？

编辑：这是我经常使用的一个有用的 Pair 类（如果需要，您可以调整您的 Tuple 类）。注意，类似于其他人的建议，这个类只是让包含的成员决定平等的问题。您的用例应该确定相等性是否真的基于所包含成员的类型。

/**
 * Adapted from http://forums.sun.com/thread.jspa?threadID=5132045
 * 
 * 
 * @author Tim Harsch
 *
 * @param <L>
 * @param <R>
 */
public class Pair<L, R> {

    private final L left;
    private final R right;

    public R getRight() {
        return right;
    } // end getter

    public L getLeft() {
        return left;
    } // end getter

    public Pair(final L left, final R right) {
        this.left = left;
        this.right = right;
    } // end constructor

    public static <A, B> Pair<A, B> create(A left, B right) {
        return new Pair<A, B>(left, right);
    } // end factory method

    @Override
    public final boolean equals(Object o) {
        if (!(o instanceof Pair<?,?>))
            return false;

        final Pair<?, ?> other = (Pair<?, ?>) o;
        return equal(getLeft(), other.getLeft()) && equal(getRight(), other.getRight());
    } // end method

    public static final boolean equal(Object o1, Object o2) {
        if (o1 == null) {
            return o2 == null;
        }
        return o1.equals(o2);
    } // end method

    @Override
    public int hashCode() {
        int hLeft = getLeft() == null ? 0 : getLeft().hashCode();
        int hRight = getRight() == null ? 0 : getRight().hashCode();

        return hLeft + (37 * hRight);
    } // end method

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('<');
        if( left == null ) {
            sb.append("null");
        } else {
            sb.append(left.toString());
        } // end if
        sb.append(',');
        if( right == null ) {
            sb.append("null");
        } else {
            sb.append(right.toString());
        } // end if
        sb.append('>');
        return sb.toString();
    } // end method
} // end class

Answer 3

我自己刚刚遇到了这个问题，在我的特殊情况下，我不需要知道类型 E。

例如：

public class Example<E> {
    E value;

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Example<?> other = (Example<?>) obj;
        if (value == null) {
            if (other.value != null)
                return false;
        } else if (!value.equals(other.value))
            return false;
        return true;
    }
}

在上面的代码中，没有因为使用了未经检查的强制转换Example<?>。类型参数通配符“?” 节省了一天。