我有一个树结构,我需要重写 equals/hashCode 方法,因为我在单元测试中使用了预期结果的检查。
树型结构的问题在于它们递归地相互引用。特别是 parent 为 child ,反之亦然。
如果所有字段都用在方法equals/hashCode中,那么就会有一个循环。问题是如何正确覆盖 then 以不违反契约(Contract)。
我将举例说明我是如何实现它的。
public class App {
public static void main(String[] args) {
Book book1 = new Book(1L, "The catcher in the rye");
Book book2 = new Book(2L, "Rich Dad Poor Dad");
BookTree bookTree1 = new BookTree(book1);
BookTree bookTreeChild1 = new BookTree(book2);
bookTree1.addChild(bookTreeChild1);
BookTree bookTree2 = new BookTree(book1);
BookTree bookTreeChild2 = new BookTree(book2);
bookTree2.addChild(bookTreeChild2);
if (!bookTree1.equals(bookTree2)) {
throw new RuntimeException("Invalid override equals");
}
}
}
class Book {
private Long id;
private String name;
public Book(Long id, String name) {
this.id = id;
this.name = name;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object object) {
if (this == object) return true;
if (object == null || getClass() != object.getClass()) return false;
Book book = (Book) object;
return Objects.equals(id, book.id) &&
Objects.equals(name, book.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
}
class Tree<T> {
private List<Tree<T>> children = new ArrayList<>();
private Tree<T> parent = null;
private T data;
public Tree(T data) {
this.data = data;
}
public Tree(T data, Tree<T> parent) {
this.data = data;
parent.addChild(this);
}
public List<Tree<T>> getChildren() {
return children;
}
public void addChild(Tree<T> child) {
child.setParent(this);
this.children.add(child);
}
public void addChild(T data) {
Tree<T> newChild = new Tree<>(data);
this.addChild(newChild);
}
public void removeChildren() {
this.children = new ArrayList<>();
}
public void addChildren(List<Tree<T>> children) {
for(Tree<T> t : children) {
t.setParent(this);
}
this.children.addAll(children);
}
private void setParent(Tree<T> parent) {
this.parent = parent;
}
public Tree<T> getParent() {
return parent;
}
public T getData() {
return this.data;
}
public void setData(T data) {
this.data = data;
}
public boolean isRoot() {
return (this.parent == null);
}
public boolean isLeaf() {
return this.children.size() == 0;
}
public void removeParent() {
this.parent = null;
}
@Override
public boolean equals(Object object) {
if (this == object) return true;
if (object == null || getClass() != object.getClass()) return false;
Tree<?> tree = (Tree<?>) object;
return Objects.equals(children, tree.children) &&
Objects.equals(data, tree.data);
}
@Override
public int hashCode() {
return Objects.hash(children, data);
}
}
class BookTree extends Tree<Book> {
public BookTree(Book data) {
super(data);
}
public BookTree(Book data, Tree<Book> parent) {
super(data, parent);
}
}
从我的实现中可以看出,我只使用了两个字段:“data”和“children”。 因此,我的问题是我是否正确实现了 equals/hashCode 方法? 如果错误,请说明错误。
最佳答案
Accordingly, my question is whether I implemented the methods equals/hashCode correctly?
首先:“什么是正确的?” ...有人可能想知道为什么树应该首先实现 equals()
和 hashCode()
。特别是 hashCode()
很棘手:该方法的要点(主要)是让您可以将相应的对象存储在 HashMap/HashSet 中。但这引发了一个大危险信号:当 hashCode()
随着时间的推移返回不同的值时,这两个类都不喜欢它。这正是您的代码将要执行的操作:每次更改树(添加/删除节点)时,hashCode()
都会给出不同的结果。
所以我们可以看看标准库做了什么:我们在那里找到了JTree ...这两种方法都没有实现!另一方面,当我们看向 AbstractSet (它是 TreeSet 的基类),我们发现这两个方法都已实现并包含成员。所以这两种方式似乎都是有效的。
回到问题:这实际上取决于您希望这两种方法如何工作。当两棵树具有完全相同的内容时,它们是否相等(意思是:子节点的顺序是否重要)?
长话短说:假设您要确保所有数据 都是平等的,并且所有子 都是平等的,并且顺序相同,那么您的实现似乎正确的。
是的,限制只检查这两个属性很有意义:当您包含父链接时,您会立即进入无法破坏的递归。
最后:您用 JUnit 标记了这个问题。这意味着您考虑为生产代码编写测试。然后这些测试应该回答你的问题。意思是:一种方法是你坐下来为这两种方法定义契约。然后你创建了一些测试用例来验证这些契约(Contract)的所有方面。然后您的测试用例会告诉您您的生产代码是否符合您的契约(Contract)。
我认为这是这里的关键点:没有通用规则告诉我们是否/如何为 Tree 类实现 equals()
和 hashCode()
.如果/如何做到这一点,您必须研究您的要求。然后您从这些知识中得出测试,然后您应用这些测试来验证给定的实现是否满足要求/契约(Contract)。
关于java - 如何在 Java 中为 Tree 正确实现 equals(), hashCode()?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/56390065/