Может ли Java помочь мне избежать кода шаблона в equals()?

Я реализую equals() путь Java 7:

@Override
public boolean equals(Object obj)
{
    if (this == obj) return true;
    if (obj == null) return false;
    if (getClass() != obj.getClass()) return false;
    MyClass other = (MyClass) obj;
    return Objects.equal(myFirstField, other.myFirstField) &&
           Objects.equal(mySecondField, other.mySecondField);
}

Есть ли способ уменьшить дублирование кода?

Я бы предпочел что-то вроде

@Override
public boolean equals(Object obj)
{
    if (Objects.equalsEarlyExit(this, obj)) return Objects.equalstEarlyExitResult(this, obj);
    MyClass other = (MyClass) obj;
    return Objects.equal(myFirstField, other.myFirstField) &&
           Objects.equal(mySecondField, other.mySecondField);
}

Или аналогичный.

Ответ 1

Стандартная API Java с автоматической активацией и созданием неэффективных объектов:

import static java.util.Arrays.*;
import java.util.List;

class BrevityBeforeEfficiency {
  int foo;
  Object bar;
  boolean baz;

  @Override
  public boolean equals(Object obj) {
    return (obj instanceof BrevityBeforeEfficiency)
        && ((BrevityBeforeEfficiency) obj).values().equals(values());
  }

  @Override
  public int hashCode() {
    return values().hashCode();
  }

  private List<?> values() {
    return asList(foo, bar, baz);
  }
}

Ответ 2

Вы можете использовать org.apache.commons.lang.builder.EqualsBuilder из commons-lang

Пример:

public boolean equals(Object other) {
    return org.apache.commons.lang.builder.EqualsBuilder.reflectionEquals(this, other);
}

Другой пример:

private boolean equalsHelper(Object obj) {
    if (obj == null) return false;
    if (getClass() != obj.getClass()) return false;
    return true;
}


public boolean equals(Object obj) {

    if (this == obj) return true;

    if(!equalsHelper(ob)) {
      return false;
    }

    MyClass other = (MyClass) obj;
    return new EqualsBuilder()
      .append(myFirstField, other.myFirstField)
      .append(mySecondField, other.mySecondField).isEquals()
}

Ответ 3

смешение в немного наследования:

public abstract class BusinessObject
{
    protected abstract Object[] getBusinessKeys();

    @Override
    public int hashCode()
    {
        return Objects.hash(getBusinessKeys());
    }

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

        if(obj == this) return true;

        if(obj.getClass() != getClass()) return false;

        BusinessObject other = (BusinessObject) obj;

        return Arrays.deepEquals(this.getBusinessKeys(), other.getBusinessKeys());
    }
}

поэтому единственный код шаблона состоит в расширении BusinessObject и однострочном getBusinessKeys():

public class Node extends BusinessObject
{
    private final String code;
    private final String name;

    public Node(String code, String name)
    {
        this.code = code;
        this.name = name;
    }

    @Override
    protected Object[] getBusinessKeys()
    {
        return new Object[] { code, name };
    }
}

Это самое простое и чистое, что я могу думать:)

Ответ 4

Здесь может быть реализация:

public abstract class EqualsHelper<T> {

    @SuppressWarnings("unchecked")
    public static <U> boolean equals(U that, Object other, EqualsHelper<U> equalsHelper) {
        return that == other || other != null && that.getClass().equals(other.getClass()) && equalsHelper.equals(that, (U) other);
    }

    public abstract boolean equals(T that, T other);

}

Тогда:

@Override
public boolean equals(Object obj) {
    return EqualsHelper.equals(this, obj, new EqualsHelper<MyClass>() {

        @Override
        public boolean equals(MyClass that, MyClass other) {
            return Objects.equal(that.myFirstField, other.myFirstField)
                && Objects.equal(that.mySecondField, other.mySecondField);
        }

    });
}

Интересно, можно ли это считать anti-pattern, поэтому не стесняйтесь обвинять меня, если вы считаете это на самом деле; )