Java 覆盖相等法与双向关系

当check实例与其他实例相等时，我得到

java.lang.StackOverflower错误

由于存在双向关系，这就是为什么我的

重写equal方法

调用

equal（）

递归地相互作用。 我是否应该在一侧的

覆盖相等方法中删除一个检查相等条件？
有什么更好的方法？一些PG建议我使用Apache的
EqualsBuilder

OrderItem.java

 public class OrderItem {
            private String id;
            private Order order;

            public OrderItem(String id, Order order) {
                this.id = id;
                this.order = order;
            }

            public void setId(String id) {
                this.id = id;
            }

            public String getId() {
                return id;
            }

            public void setOrder(Order order) {
                this.order = order;
            }

            public Order getOrder() {
                return order;
            }

            @Override
            public boolean equals(Object object) {
                if (this == object) {
                    return true;
                }
                if (!(object instanceof OrderItem)) {
                    return false;
                }
                final OrderItem other = (OrderItem)object;
                if (!(id == null ? other.id == null : id.equals(other.id))) {
                    return false;
                }
                if (!(order == null ? other.order == null : order.equals(other.order))) {
                    return false;
                }
                return true;
            }
        }

Order.java

        public class Order {
            private String id;
            private List<OrderItem> orderItemList;

            public Order(String id) {
                this.id = id;
            }

            public void setId(String id) {
                this.id = id;
            }

            public String getId() {
                return id;
            }

            public void setOrderItemList(List<OrderItem> orderItemList) {
                this.orderItemList = orderItemList;
            }

            public List<OrderItem> getOrderItemList() {
                return orderItemList;
            }

            @Override
            public boolean equals(Object object) {
                if (this == object) {
                    return true;
                }
                if (!(object instanceof Order)) {
                    return false;
                }
                final Order other = (Order)object;
                if (!(id == null ? other.id == null : id.equals(other.id))) {
                    return false;
                }
                if (!(orderItemList == null ? other.orderItemList == null : orderItemList.equals(other.orderItemList))) {
                    return false;
                }
                return true;
            }
        }

公共类秩序{
私有字符串id；
私有列表orderItemList；
公共秩序（字符串id）{
this.id=id；
}
公共无效集合id（字符串id）{
this.id=id；
}
公共字符串getId（）{
返回id；
}
public void setOrderItemList（列表orderItemList）{
this.orderItemList=orderItemList；
}
公共列表getOrderItemList（）{
返回orderItemList；
}
@凌驾
公共布尔等于（对象）{
if（this==对象）{
返回true；
}
if（！（订单的对象实例））{
返回false；
}
最终订单其他=（订单）对象；
if（！（id==null？other.id==null:id.equals（other.id）））{
返回false；
}
如果（！（orderItemList==null？other.orderItemList==null:orderItemList.equals（other.orderItemList）））{
返回false；
}
返回true；
}
}

试验

publicstaticvoidmain（字符串[]args）{
订单1=新订单（“1”）；
List orderItemList=新建ArrayList（）；
添加（新的OrderItem（“1”，order1））；
添加（新的OrderItem（“2”，order1））；
order1.setOrderItemList（orderItemList）；
订单2=新订单（“1”）；
List orderItemList2=新建ArrayList（）；
orderItemList2.add（新的OrderItem（“1”，order2））；
添加（新的OrderItem（“2”，order2））；
order2.setOrderItemList（orderItemList2）；
if（order1.equals（order2））{
系统输出打印项次（“相等”）；
}否则{
System.out.println（“不相等”）；
}
}
我会将其重写为仅使用
id
属性进行相等性检查。但这一点非常重要：如果您希望实体在Java集合中正确运行，请不要忘记重写
hashcode（）
方法。
OrderItem是否需要知道其包含的顺序？假设是这样的-它属于一个订单或另一个订单的事实是否改变了它的性质（即，如果两个订单项具有相同的ID，那么无论包含的订单是什么，您是否可以说它们是相等的）？如果我们使用JPA onetomany双向，我们需要知道
        public static void main(String[] args) {
            Order order1 = new Order("1");
            List<OrderItem> orderItemList = new ArrayList<OrderItem>();
            orderItemList.add(new OrderItem("1", order1));
            orderItemList.add(new OrderItem("2", order1));
            order1.setOrderItemList(orderItemList);


            Order order2 = new Order("1");
            List<OrderItem> orderItemList2 = new ArrayList<OrderItem>();
            orderItemList2.add(new OrderItem("1", order2));
            orderItemList2.add(new OrderItem("2", order2));
            order2.setOrderItemList(orderItemList2);

            if(order1.equals(order2)) {
                System.out.println("Equal");
            } else {
                System.out.println("Not Equal");
            }
        }