[이펙티브 자바] Item14. Comparable을 구현할지 고민하라. (compareTo 기본 규약)

 

item14. Comparable을 구현할지 고민하라. 

 

 

compareTo

: compareTo는 Comparable 인터페이스의 유일한 메서드로 Objet.equals(단순 동치성)에 더해서 순서까지 비교할 수 있으며 Generic을 지원한다. 

Comparable을 구현했다는 것은 그 클래스의 인스턴스들에는 자연적인 순서 natural order가 있음을 뜻한다. 

알파벳이나 숫자, 연대와 같이 순서가 명확한 값 클래스를 작성한다라면 반드시 Comparable 인터페이스를 구현하자. 

 

 

compareTo 일반 규약 

BigDecimal n1 = BigDecimal.valueOf(23134134);
BigDecimal n2 = BigDecimal.valueOf(11231230);
BigDecimal n3 = BigDecimal.valueOf(53534552);
BigDecimal n4 = BigDecimal.valueOf(11231230);

1️⃣ Comparable을 구현한 클래스는 모든 x,y에 대해 sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) 여야 한다. 

-> 두 객체의 참조의 순서를 바꿔 비교해도 예상한 결과가 나와야 한다. 

// p.88 대칭성
System.out.println("n1.compareTo(n2) = " + n1.compareTo(n2));
System.out.println("n2.compareTo(n1) = " + n2.compareTo(n1));

 

즉, 첫 번째 객체가 두 번째 객체보다 작으면, 두 번째가 첫 번째보다 커야 한다. 

첫 번째가 두 번째와 크기가 같다면, 두 번째는 첫 번째와 같아야 한다. 

첫 번째가 두 번째보다 크면, 두 번째는 첫 번째보다 작아야 한다. 

 

 

2️⃣ Comparable을 구현한 클래스는 추이성을 보장해야 한다. x.compareTo(y) > 0 && y.compareTo(z) 이면 x.compareTo(z) 여야 한다. 

-> 첫 번째가 두 번째보다 크고 두 번째가 세 번째보다 크면, 첫 번째는 세 번째보다 커야 한다는 뜻이다. 

// p.89 추이성
System.out.println("n3.compareTo(n1) > 0 = " + (n3.compareTo(n1) > 0));
System.out.println("n1.compareTo(n2) > 0 = " + (n1.compareTo(n2) > 0));
System.out.println("n3.compareTo(n2) > 0 = " + (n3.compareTo(n2) > 0));

 

3️⃣ Comparable을 구현한 클래스는 모든 z에 대해 x.compareTo(y) == 이면 sgn(x.compareTo(z)) == sgn(y.compareTo(z))이다. 

-> 크기가 같은 객체들끼리는 어떤 객체와 비교하더라도 항상 같아야 한다. 

// p.89 일관성
System.out.println("n4.compareTo(n2) = " + n4.compareTo(n2));
System.out.println("n2.compareTo(n1) = " + n2.compareTo(n1));
System.out.println("n4.compareTo(n1) = " + n4.compareTo(n1));

 

4️⃣ (x.compareTo(y) == 0) == (x.equals(y)) 여야 한다. (권고가 필수는 아니지만 꼭 지키는게 좋다.)  

Comparable을 구현하고 이 권고를 지키지 않는 모든 클래스는 그 사실을 명시해야 한다. 

-> compareTo 메서드로 수행한 동치성 테스트의 결과가  equals와 같아야 한다. 

// p.89 compareTo가 0이라면 equals는 true여야 한다. (아닐 수도 있고...)
BigDecimal oneZero = new BigDecimal("1.0");
BigDecimal oneZeroZero = new BigDecimal("1.00");
System.out.println("oneZero.compareTo(oneZeroZero) = " + oneZero.compareTo(oneZeroZero)); // Tree, TreeMap
System.out.println("oneZero.equals(oneZeroZero) = " + oneZero.equals(oneZeroZero)); // 순서가 없는 컬렉션

-> 이 예제를 실행하면 

이렇게 equals와 compareTo의 결과가 같지 않은 것을 확인할 수 있다. 

 

BigDecimal 클래스는 compareTo와 equals가 일관되지 않은 클래스로 빈 HashMap 인스턴스를 생성한 다음에 new BigDecimal("1.0"), new Decimal("1.00")을 차례로 추가하면 이 두 BigDecimal은 equals 메서드로 비교하면 서로 다르기 때문에 HashSet은 두개의 원소를 가지만, 

HashSet 대신에 TreeSet을 사용하면 원소를 하나만 갖게 된다. compareTo 메서드로 비교하면 두 BigDecimal 인스턴스가 똑같기 ㄸ매ㅜㄴ이다. 

/**
 * Compares this {@code BigDecimal} with the specified
 * {@code Object} for equality.  Unlike {@link
 * #compareTo(BigDecimal) compareTo}, this method considers two
 * {@code BigDecimal} objects equal only if they are equal in
 * value and scale (thus 2.0 is not equal to 2.00 when compared by
 * this method).
 *
 * @param  x {@code Object} to which this {@code BigDecimal} is
 *         to be compared.
 * @return {@code true} if and only if the specified {@code Object} is a
 *         {@code BigDecimal} whose value and scale are equal to this
 *         {@code BigDecimal}'s.
 * @see    #compareTo(java.math.BigDecimal)
 * @see    #hashCode
 */
@Override
public boolean equals(Object x) {
    if (!(x instanceof BigDecimal))
        return false;
    BigDecimal xDec = (BigDecimal) x;
    if (x == this)
        return true;
    if (scale != xDec.scale)
        return false;
    long s = this.intCompact;
    long xs = xDec.intCompact;
    if (s != INFLATED) {
        if (xs == INFLATED)
            xs = compactValFor(xDec.intVal);
        return xs == s;
    } else if (xs != INFLATED)
        return xs == compactValFor(this.intVal);

    return this.inflated().equals(xDec.inflated());
}

(thus 2.0 is not equal to 2.00 when compared by this method).

라고 알려주고 있다.