[java] Java에서 equals 메소드를 재정의하는 방법

항목 10 : 등호를 대체 할 때 일반 계약을 준수하십시오.

Effective Java에 따르면equals 메서드 재정의는 간단 해 보이지만 잘못된 방법은 여러 가지가 있으며 결과는 끔찍할 수 있습니다. 문제를 피하는 가장 쉬운 방법은 equals메서드 를 재정의하지 않는 것 입니다.이 경우 클래스의 각 인스턴스는 자신과 동일합니다. 다음 조건 중 하나가 적용되는 경우 이는 올바른 조치입니다.

• 클래스의 각 인스턴스는 본질적으로 고유 합니다. 이는 값이 아닌 활성 엔티티를 나타내는 Thread와 같은 클래스에 해당됩니다. Object에서 제공하는 equals 구현은 이러한 클래스에 대해 정확히 올바른 동작을합니다.

• 클래스가 “논리적 동등성”테스트를 제공 할 필요가 없습니다. 예를 들어 java.util.regex.Pattern은 두 개의 Pattern 인스턴스가 정확히 동일한 정규식을 나타내는 지 확인하기 위해 equals를 재정의 할 수 있었지만 디자이너는 클라이언트가이 기능을 필요로하거나 원할 것이라고 생각하지 않았습니다. 이러한 상황에서는 Object에서 상속 된 equals 구현이 이상적입니다.

• 수퍼 클래스는 이미 equals를 재정의 했으며 수퍼 클래스 동작은이 클래스에 적합합니다. 예를 들어, 대부분의 Set 구현은 AbstractSet의 equals 구현, AbstractList의 List 구현 및 AbstractMap의 Map 구현을 상속합니다.

• 클래스는 private 또는 package-private 이며 equals 메서드가 절대로 호출되지 않을 것입니다. 위험을 극도로 회피하는 경우 equals 메서드를 재정 의하여 실수로 호출되지 않도록 할 수 있습니다.

이 equals메서드는 등가 관계를 구현합니다. 다음과 같은 속성이 있습니다.

• 재귀 : null이 아닌 참조 값 x에 대해 x.equals(x)true를 반환해야합니다.

• 대칭 : null 이외의 참조 값의 경우 x와는 y, x.equals(y)그리고 한편 y.equals (X)가 true를 반환하는 경우에만 경우에 true를 반환해야합니다.

• 트랜은 : null 이외의 참조 값의 경우 x, y, z, 경우 x.equals(y)반환 true및 y.equals(z)반환 true하고 x.equals(z)반환해야합니다 true.

• 일관성 : Null이 아닌 참조 값 x및의 y경우 같음 비교에 사용 된 정보가 수정되지 않은 경우를 여러 번 호출하면 x.equals(y)일관 적으로를 반환 true하거나 일관 되게 반환해야합니다 false.

• null이 아닌 참조 값의 x경우 x.equals(null)를 반환해야합니다 false.

다음은 고품질 equals 방법을위한 레시피입니다.

1. ==연산자를 사용하여 인수가이 개체에 대한 참조인지 확인합니다. 그렇다면 true를 반환하십시오. 이는 성능 최적화에 불과하지만 잠재적으로 비교 비용이 많이 드는 경우 수행 할 가치가 있습니다.

2. instanceof연산자를 사용하여 인수의 유형이 올바른지 확인하십시오. 그렇지 않은 경우 false를 반환합니다. 일반적으로 올바른 유형은 메서드가 발생하는 클래스입니다. 가끔이 클래스에 의해 구현 된 일부 인터페이스입니다. 클래스가 인터페이스를 구현하는 클래스 간의 비교를 허용하도록 같음 계약을 구체화하는 인터페이스를 구현하는 경우 인터페이스를 사용합니다. Set, List, Map 및 Map.Entry와 같은 컬렉션 인터페이스에는이 속성이 있습니다.

3. 인수를 올바른 유형으로 캐스트하십시오. 이 캐스트는 instanceof test가 선행되었으므로 성공할 수 있습니다.

4. 클래스의 각 “중요한”필드에 대해 인수의 해당 필드가이 개체의 해당 필드와 일치하는지 확인합니다. 이 모든 테스트가 성공하면 true를 반환합니다. 그렇지 않으면 false를 반환합니다. 2 단계의 유형이 인터페이스 인 경우 인터페이스 메서드를 통해 인수의 필드에 액세스해야합니다. 유형이 클래스 인 경우 액세스 가능성에 따라 필드에 직접 액세스 할 수 있습니다.

5. 유형이 float또는 이 아닌 기본 필드의 경우 비교에 연산자를 double사용하십시오 ==. 개체 참조 필드의 경우 equals메서드를 재귀 적으로 호출합니다 . 위한 float필드 정적 사용 Float.compare(float, float)방법; 과에 대한 double필드 사용 Double.compare(double, double). float 및 double 필드의 특수 처리는 Float.NaN, -0.0f및 유사한 double 값에 의해 필요 합니다. 비교할 수 있지만 float및 double필드 정적 방법으로 Float.equals하고 Double.equals,이 성능 저하있을 것입니다 모든 비교에 오토 박싱을 수반한다. 들어 array필드, 각 요소에 이러한 지침을 적용 할 수 있습니다. 배열 필드의 모든 요소가 중요한 경우 Arrays.equals방법 중 하나를 사용하십시오 .

6. 일부 개체 참조 필드에는 합법적으로 null. 가능성을 방지하려면 NullPointerException정적 메서드를 사용하여 해당 필드가 같은지 확인하십시오 Objects.equals(Object, Object).

   // Class with a typical equals method
   
   public final class PhoneNumber {
   
       private final short areaCode, prefix, lineNum;
   
       public PhoneNumber(int areaCode, int prefix, int lineNum) {
   
           this.areaCode = rangeCheck(areaCode,  999, "area code");
   
           this.prefix   = rangeCheck(prefix,    999, "prefix");
   
           this.lineNum  = rangeCheck(lineNum,  9999, "line num");
   
       }
   
       private static short rangeCheck(int val, int max, String arg) {
   
           if (val < 0 || val > max)
   
              throw new IllegalArgumentException(arg + ": " + val);
   
           return (short) val;
   
       }
   
       @Override public boolean equals(Object o) {
           if (o == this)
               return true;
           if (!(o instanceof PhoneNumber))
               return false;
           PhoneNumber pn = (PhoneNumber)o;
           return pn.lineNum == lineNum && pn.prefix == prefix
                   && pn.areaCode == areaCode;
       }
       ... // Remainder omitted
   
   }

답변

public boolean equals(Object other){
    boolean result;
    if((other == null) || (getClass() != other.getClass())){
        result = false;
    } // end if
    else{
        People otherPeople = (People)other;
        result = name.equals(otherPeople.name) &&  age == otherPeople.age;
    } // end else

    return result;
} // end equals

public boolean equals(Object obj) {

    // same instance
    if (obj == this) {
        return true;
    }
    // null
    if (obj == null) {
        return false;
    }
    // type
    if (!getClass().equals(obj.getClass())) {
        return false;
    }
    // cast and compare state
    Person other = (Person) obj;
    return Objects.equals(name, other.name) && Objects.equals(age, other.age);
}

public final class Equals {

    private Equals() {
        // private constructor, no instances allowed
    }

    /**
     * Convenience equals implementation, does the object equality, null and type checking, and comparison of the identifying state
     *
     * @param instance       object instance (where the equals() is implemented)
     * @param other          other instance to compare to
     * @param stateAccessors stateAccessors for state to compare, optional
     * @param <T>            instance type
     * @return true when equals, false otherwise
     */
    public static <T> boolean as(T instance, Object other, Function<? super T, Object>... stateAccessors) {
        if (instance == null) {
            return other == null;
        }
        if (instance == other) {
            return true;
        }
        if (other == null) {
            return false;
        }
        if (!instance.getClass().equals(other.getClass())) {
            return false;
        }
        if (stateAccessors == null) {
            return true;
        }
        return Stream.of(stateAccessors).allMatch(s -> Objects.equals(s.apply(instance), s.apply((T) other)));
    }
}

public boolean equals(Object obj) {
    return Equals.as(this, obj, t -> t.name, t -> t.age);
}