아이템 14. Comparable을 구현할지 고려하라

[chikeem90]

Comparable

public interface Comparable<T> {
    public int compareTo(T o);
}

• Comparable의 compareTo는 동치성뿐만 아니라 순서까지 비교 가능.
• 자바 플랫폼 라이브러리의 모든 값 클래스와 열거 타입이 Comparable을 구현함.
• 알파벳, 숫자, 연대 같이 순서가 명확한 값 클래스를 작성한다면 반드시 Comparable 인터페이스를 구현하자.

compareTo 메서드의 일반 규약

1. 두 객체의 참조의 순서를 바꿔 비교해도 예상한 결과가 나와야 함.
2. 첫 번째가 두 번째보다 크고 두 번째가 세 번째보다 크면, 첫 번째는 세 번째보다 커야 함.
3. 크기가 같은 객체들끼리는 어떤 객체와 비교하더라도 항상 같아야 함.
4. (필수X) compareTo 메서드로 수행한 동치성 테스트 결과가 equals의 결과와 같야아 함.
   • 지키지 않을 경우, 컬렉션이 구현한 인터페이스 (Collection, Set, Map 등) 에 정의된 동작과 다르게 작동할 수 있음.
   • 정렬된 컬렉션들은 동치성을 비교할 때 equals 대신 compareTo를 사용하기 때문.

Comparable 주의사항

• 기존 클래스를 확장한 구체 클래스에서 새로운 값 컴포넌트를 추가했다면 compareTo 규약을 지킬 수 없음.
• Comparable을 구현한 클래스를 확장해 값 컴포넌트를 추가하고 싶을 경우, 확장하는 대신 독립된 클래스를 만들고, 해당 클래스에 원 클래스의 인스턴스를 가리키는 필드를 두는 방식으로 처리하고, 내부 인스턴스를 반환하는 뷰 메서드를 제공하는 형태로 처리해야 함.

compareTo 메서드 작성 요령

• Comparable은 제네릭 인터페이스이므로 타입을 확인하거나 형변환할 필요 없음.
• 객체 참조 필드를 비교하려면 compareTo 메서드를 재귀적으로 호출 필요.
• Comparable을 구현하지 않은 필드나 표준이 아닌 순서로 비교해야 한다면 Comparator를 대신 사용.
• 정수 기본 타입, 실수 기본 타입을 비교할 때는 박싱된 기본 타입 클래스들에 새로 추가된 정적 메서드인 compare를 이용.
• 클래스에 핵심 필드가 여러 개라면 가장 핵심적인 필드부터 비교.

Comparator

• 자바 8에서는 Comparator 인터페이스가 비교자 생성 메서드를 제공하여 메서드 연쇄 방식으로 비교자를 생성할 수 있음.
• 이를 활용하여 Comparable 인터페이스의 compareTo 메서드를 구현 가능.

[JoisFe]

알고리즘 문제에서 정렬 커스텀이 필요할때 지긋지긋하게 Comparable 인터페이스의 compareTo 메서드를 오버라이딩 하였는데 제대로 알아보지도 않고 막무가내로 썻던 경험이 있습니다.

특히 intelliJ 에서 특정 클래스가 Comparable을 구현하게 한 후 compareTo 메서드를 재정의 하면

class Num implements Comparable<Num> {
    private int num1;
    private int num2;

    @Override
    public int compareTo(Num o) {
        if (this.num1 == o.num1) {
            return this.num2 - o.num2;
        }
        return this.num1 - o.num1;
    }
}

이러한 equals 메서드를 재정의 하라고 경고를 보여주었는데

(필수X) compareTo 메서드로 수행한 동치성 테스트 결과가 equals의 결과와 같야아 함.

• 지키지 않을 경우, 컬렉션이 구현한 인터페이스 (Collection, Set, Map 등) 에 정의된 동작과 다르게 작동할 수 있음.
• 정렬된 컬렉션들은 동치성을 비교할 때 equals 대신 compareTo를 사용하기 때문.

물론 equals를 재정의 했다면 hashCode 또한 재정의 해야 겠죠!! (#23 제가 정리한 자료입니다 ㅎㅎ...)

위 코드를 지금까지의 규약을 지키면 아래와 같습니다.

class Num implements Comparable<Num> {
    private int num1;
    private int num2;

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Num num = (Num) o;
        return num1 == num.num1 && num2 == num.num2;
    }

    @Override
    public int hashCode() {
        return Objects.hash(num1, num2);
    }

    @Override
    public int compareTo(Num o) {
        if (this.num1 == o.num1) {
            return this.num2 - o.num2;
        }
        return this.num1 - o.num1;
    }
}

이러한 이유가 있었군요!

이번 글을 통해 Comparable, compareTo에 대해 좀 더 알게되었습니다 감사합니다..

[chikeem90]

(필수X) compareTo 메서드로 수행한 동치성 테스트 결과가 equals의 결과와 같야아 함.

이 부분을 좀 더 정리해보려고 하는데요,,
책에서 나온 것처럼 TreeSet과 HashSet을 비교해봤습니다.

public class MainClass {
	public static void main(String[] args) {
		Set<BigDecimal> fooTreeSet = new TreeSet<>();
		Set<BigDecimal> fooHashSet = new HashSet<>();
		BigDecimal decimal1 = new BigDecimal("123.0");
		BigDecimal decimal2 = new BigDecimal("123.000");
		fooTreeSet.add(decimal1);
		fooTreeSet.add(decimal2);
		fooHashSet.add(decimal1);
		fooHashSet.add(decimal2);
		System.out.printf("BigDecimal equals 결과 = %b", decimal1.equals(decimal2));
		System.out.println();
		System.out.printf("BigDecimal compareTo 결과 = %b", decimal1.compareTo(decimal2));
		System.out.println();
		System.out.println("fooTreeSet");
		fooTreeSet.forEach(System.out::println);
		System.out.println("fooHashSet");
		fooHashSet.forEach(System.out::println);
	}
}

위 코드의 결과는 이렇네요

BigDecimal equals 결과 = false
BigDecimal compareTo 결과 = true
fooTreeSet
123.0
fooHashSet
123.000
123.0

TreeSet은 내부적으로 TreeMap으로 구현하고 있고, TreeMap의 put 메서드를 보면 아래와 같습니다.
비교를 compareTo로 하고, 같은 경우는 동일한 것으로 간주해서 새로 put하는 value로 덮어씌워버리네요.

    public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                // 여기서 compareTo로 비교를 하고 만약 같은 경우 새로운 value로 덮어씌워버림
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html#compareTo(java.math.BigDecimal)
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html#equals(java.lang.Object)

BigDecimal의 compareTo와 equals의 설명을 보면, compareTo의 경우 2.0와 2.00 처럼 scale이 달라도 동일한 것으로 간주한다고 되어 있고 equals의 경우 scale이 다르면 다른 것으로 간주한다고 되어 있네요.
그렇기 때문에 이렇게 TreeSet과 HashSet의 작동 방식이 달라지는 거 같고, 이걸 의도하지 않는 이상은 compareTo와 equals가 일관되게끔 작성해야겠네요.

[chikeem90]

Comparable vs Comparator

https://stackoverflow.com/a/4108764

해당 인스턴스에 자연적인 순서가 있는 경우 Comparable을 구현해서 compareTo로 순서 설정.
이미 Comparable을 구현한 자연적인 순서 (String, Integer 등) 외에 다른 순서로 정렬하고 싶을 경우 Comparator 사용.

네이밍만 보면,, Comparable은 이게 비교되어질 수 있다, 순서가 있다, 정렬될 수 있다의 의미인거고,, Comparator는 정렬하기 위한 도구로 보면 될 거 같네요.

'이 객체는 정렬될 수 있고, 기본적으로 정렬되어야 하는 기준이 있다'의 경우에만 Comparable을 구현하고,, 그 외 정렬할 때 Comparator를 쓰거나 하면 될 거 같네요.

[Irisation23]

만약 Comparable과 Comparator의 찐득한 동작이 궁금하다면 ⁉️ 참조자료