Unit 6.2 — Comparable<T> 의 자연 순서
F-LAB JAVA · 3주차 · Phase 6 · 객체 비교
📌 학습 목표
이 Unit을 끝내면 다음을 답할 수 있어야 한다.
-
Comparable<T>인터페이스 의 정확한 정의는? -
compareTo메서드 의 반환값 의미는? - 자연 순서 (Natural Ordering) 가 무엇인가?
- compareTo 의 5가지 계약 (반사성, 대칭성, 추이성 등) 은?
-
equals와compareTo의 일관성 의 의미와 중요성은? -
Integer.compare()같은 정적 메서드를 쓰는 이유는? - 다중 필드 비교 의 우아한 작성 방법은?
- TreeMap, TreeSet, Collections.sort 와 Comparable 의 관계는?
- 자바 표준의 Comparable 구현 (Integer, String, LocalDate) 분석은?
🎯 핵심 한 문장
Comparable<T>는 "자기 자신을 어떻게 비교하는가" 를 정의하는 인터페이스다.
compareTo메서드가 음수 (this < other), 0 (같음), 양수 (this > other) 를 반환하며,
이로 인해 자연 순서 (Natural Ordering) 가 정의된다.
Collections.sort(list),TreeMap,TreeSet이 이 순서를 활용해 자동 정렬.
equals와compareTo의 일관성 을 지키지 않으면 TreeSet 의 contains 와 HashSet 의 contains 가 다른 결과를 반환.
비유 — 학생의 자기 순위
Comparable = 학생 스스로 결정한 순위 기준
Student implements Comparable<Student> {
compareTo(other):
- 내 점수가 높으면 양수 (나는 더 위)
- 내 점수가 낮으면 음수 (나는 더 아래)
- 같으면 0
이로 인해:
- 학생들을 한 줄로 세울 수 있음 (자연 순서)
- Collections.sort 가 자동으로 정렬
- TreeMap 이 학생을 키로 자동 정렬 보관→ Comparable = 자기 정렬 기준 + 자연 순서.
🧭 9개 섹션 로드맵
1. Comparable<T> 인터페이스의 정의
2. compareTo 의 반환값
3. 자연 순서 (Natural Ordering)
4. compareTo 의 5가지 계약
5. equals 와 compareTo 의 일관성
6. 다중 필드 비교
7. TreeMap, TreeSet, Collections.sort 의 활용
8. 자바 표준의 Comparable 분석
9. 면접 + 자기 점검1️⃣ Comparable 인터페이스의 정의
1.1 인터페이스 정의
package java.lang;
public interface Comparable<T> {
int compareTo(T other);
}핵심:
java.lang패키지 (기본 import)- 단 하나의 메서드 —
compareTo - 제네릭 — 자기 타입 매개변수 (보통 자기 자신)
- 함수형 인터페이스 는 아님 (관례적으로 lambda 부적합)
1.2 기본 구현 예
public class Person implements Comparable<Person> {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person other) {
return Integer.compare(this.age, other.age);
// 나이 오름차순
}
}
// 사용
Person p1 = new Person("Alice", 25);
Person p2 = new Person("Bob", 30);
Person p3 = new Person("Charlie", 25);
p1.compareTo(p2); // 음수 (25 < 30)
p2.compareTo(p1); // 양수 (30 > 25)
p1.compareTo(p3); // 0 (25 == 25)1.3 자기 타입 매개변수
// 권장: Comparable<자기 자신>
public class Person implements Comparable<Person> {
@Override
public int compareTo(Person other) { ... }
}
// 부모 타입과 비교 (드물게)
public class Child extends Parent implements Comparable<Parent> {
@Override
public int compareTo(Parent other) { ... }
// Child 는 Comparable<Parent>
}
// 제네릭 사용
public class Pair<T extends Comparable<T>> implements Comparable<Pair<T>> {
private T value;
@Override
public int compareTo(Pair<T> other) {
return value.compareTo(other.value);
}
}1.4 자바 표준의 Comparable 구현
// 모든 숫자 타입
public final class Integer implements Comparable<Integer> { ... }
public final class Long implements Comparable<Long> { ... }
public final class Double implements Comparable<Double> { ... }
// 문자열
public final class String implements Comparable<String> { ... }
// 날짜/시간
public final class LocalDate implements Comparable<ChronoLocalDate> { ... }
public final class LocalDateTime implements Comparable<ChronoLocalDateTime<?>> { ... }
// 자료형
public final class BigDecimal extends Number implements Comparable<BigDecimal> { ... }
public final class BigInteger extends Number implements Comparable<BigInteger> { ... }
// Enum
public abstract class Enum<E extends Enum<E>> implements Comparable<E> {
public final int compareTo(E other) {
return this.ordinal() - other.ordinal();
// 선언 순서 기반
}
}1.5 Comparable 의 활용
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
// Collections.sort — Comparable 자동 활용
Collections.sort(numbers); // 자연 순서 정렬
// [1, 1, 2, 3, 4, 5, 6, 9]
// List.sort + null 비교기
numbers.sort(null); // null = 자연 순서
// TreeMap, TreeSet — 자동 정렬
TreeSet<String> sortedNames = new TreeSet<>();
sortedNames.add("Charlie");
sortedNames.add("Alice");
sortedNames.add("Bob");
// 내부: [Alice, Bob, Charlie]
// Collections.max/min
Integer max = Collections.max(numbers); // 9
Integer min = Collections.min(numbers); // 11.6 Comparable 자체는 인스턴스화 불가
// Comparable 은 인터페이스
Comparable<Integer> c = ...; // 어떻게 만드나?
// 직접 인스턴스화 불가
// new Comparable<Integer>() { ... }; // 익명 클래스 가능
// 보통:
// 1. 클래스가 implements
public class MyClass implements Comparable<MyClass> { ... }
// 2. Comparable 의 자식을 매개변수로
public <T extends Comparable<T>> T max(List<T> list) { ... }
// 3. 와일드카드
public <T extends Comparable<? super T>> void sort(List<T> list) { ... }1.7 자기 점검 답변
Comparable 의 본질과 정의는?
답:
-
본질:
- "자기 자신을 어떻게 비교하는가"
- 자연 순서 정의
- 자기 정렬 기준
-
정의:
java.lang패키지- 단일 메서드
compareTo(T) - 제네릭 (보통 자기 자신)
-
구현체:
- Integer, Long, Double 등 숫자
- String, LocalDate 등
- 사용자 클래스도 가능
→ Java 의 기본 비교 메커니즘.
2️⃣ compareTo 의 반환값
2.1 세 가지 반환값
compareTo(other) 의 반환값:
- **음수** (보통 -1): this < other (this 가 더 작음)
- **0**: this == other (같음)
- **양수** (보통 1): this > other (this 가 더 큼)
정확한 수치는 무관, 부호만 중요.2.2 기본 예시
Integer a = 5;
Integer b = 10;
a.compareTo(b); // 음수 (-5 또는 -1 등) — a < b
b.compareTo(a); // 양수 (5 또는 1 등) — b > a
a.compareTo(5); // 0 — 같음
// String 의 compareTo
String s1 = "apple";
String s2 = "banana";
s1.compareTo(s2); // 음수 — apple 이 사전순 먼저
s2.compareTo(s1); // 양수2.3 음수/양수 의 정확한 값
// 자바 표준은 정확한 수치 명시 안 함
// 예: Integer.compareTo
public int compareTo(Integer other) {
return (this.value < other.value) ? -1 : ((this.value == other.value) ? 0 : 1);
// 또는 더 자주:
return Integer.compare(this.value, other.value);
// Integer.compare 는 -1, 0, 1 반환
}
// String.compareTo
public int compareTo(String other) {
// 문자 코드 차이 반환
// 예: "a".compareTo("b") = 'a' - 'b' = -1
// 또는 길이 차이
}
// LocalDate.compareTo
public int compareTo(ChronoLocalDate other) {
int cmp = (int)(toEpochDay() - other.toEpochDay());
// 일 수 차이
}2.4 부호만 중요한 이유
// 다음 모든 표현이 같은 의미:
// "a 가 b 보다 작다"
a.compareTo(b) < 0;
a.compareTo(b) == -1; // 너무 엄격
a.compareTo(b) <= -1;
Integer.signum(a.compareTo(b)) == -1; // 부호만
// 권장: < 0, == 0, > 0
if (a.compareTo(b) < 0) {
// a 가 작음
}
if (a.compareTo(b) == 0) {
// 같음
}
if (a.compareTo(b) > 0) {
// a 가 큼
}2.5 흔한 실수 — 직접 뺄셈
// ❌ 잘못 — 오버플로우 가능
@Override
public int compareTo(Person other) {
return this.age - other.age; // 위험!
}
// 예: this.age = Integer.MAX_VALUE, other.age = -1
// 결과: MAX_VALUE - (-1) = MAX_VALUE + 1 = MIN_VALUE (음수!)
// 의도와 반대
// ✓ 권장: Integer.compare
@Override
public int compareTo(Person other) {
return Integer.compare(this.age, other.age);
}
// 내부 구현 (안전):
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}2.6 정적 compare 메서드 활용
// Java 7+ 의 정적 compare 메서드들
Integer.compare(a, b); // int 비교
Long.compare(a, b); // long 비교
Double.compare(a, b); // double 비교 (NaN 처리)
Boolean.compare(a, b); // boolean 비교
Character.compare(a, b); // char 비교
// 객체 비교
Objects.compare(a, b, Comparator.naturalOrder());
// 활용
@Override
public int compareTo(Person other) {
return Integer.compare(this.age, other.age);
}
@Override
public int compareTo(Product other) {
return Double.compare(this.price, other.price);
}
@Override
public int compareTo(Date other) {
return Long.compare(this.timestamp, other.timestamp);
}2.7 BigDecimal 의 compareTo vs equals
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");
a.compareTo(b); // 0 (같음, 값으로)
a.equals(b); // false! (scale 다름)
// BigDecimal 의 equals 는 scale 도 비교
// compareTo 는 값만 비교→ BigDecimal 사용 시 비교 방법 주의.
2.8 자기 점검 답변
compareTo 의 반환값과 안전한 비교 방법은?
답:
-
반환값:
- 음수: this < other
- 0: this == other
- 양수: this > other
- 정확한 수치 무관, 부호만 중요
-
흔한 실수:
- 직접 뺄셈
a - b→ 오버플로우 위험 - 예: MAX_VALUE - (-1) = MIN_VALUE
- 직접 뺄셈
-
권장:
Integer.compare(a, b)등 정적 메서드- 자바 표준의 안전한 구현
- 오버플로우 처리
3️⃣ 자연 순서 (Natural Ordering)
3.1 자연 순서의 정의
자연 순서 (Natural Ordering):
Comparable 의 compareTo 가 정의하는 순서.
특징:
- 클래스에 내재된 순서
- 외부 Comparator 불필요
- Collections.sort(list) 가 자동 활용
- TreeMap, TreeSet 의 기본 순서3.2 자바 표준의 자연 순서
Integer, Long: 숫자 오름차순
Integer.compare(a, b);
String: 사전순 (lexicographic)
- Unicode 값 기반
- 대문자 < 소문자 (Z < a)
LocalDate: 시간 오름차순
- 1900-01-01 < 2025-01-01
BigDecimal: 값 비교 (scale 무관)
Enum: 선언 순서 (ordinal)
enum Status { DRAFT, ACTIVE, COMPLETED }
// DRAFT < ACTIVE < COMPLETED3.3 자연 순서의 활용
// 1. Collections.sort
List<String> names = Arrays.asList("Charlie", "Alice", "Bob");
Collections.sort(names);
// → [Alice, Bob, Charlie]
// 2. Stream.sorted()
List<Integer> sorted = Stream.of(3, 1, 4, 1, 5, 9)
.sorted()
.collect(Collectors.toList());
// → [1, 1, 3, 4, 5, 9]
// 3. TreeSet
TreeSet<LocalDate> dates = new TreeSet<>();
dates.add(LocalDate.of(2025, 12, 31));
dates.add(LocalDate.of(2025, 1, 1));
dates.add(LocalDate.of(2025, 6, 15));
// 내부: [2025-01-01, 2025-06-15, 2025-12-31]
// 4. PriorityQueue
PriorityQueue<Integer> queue = new PriorityQueue<>();
queue.add(3);
queue.add(1);
queue.add(2);
queue.poll(); // 1 (가장 작음)
queue.poll(); // 2
queue.poll(); // 33.4 ASCII 와 String 자연 순서
// ASCII 코드 기반
"a" < "b" // 'a' = 97, 'b' = 98
"A" < "a" // 'A' = 65, 'a' = 97
"Z" < "a" // 'Z' = 90, 'a' = 97
// 정렬 결과
List<String> mixed = Arrays.asList("Banana", "apple", "Cherry");
Collections.sort(mixed);
// → [Banana, Cherry, apple]
// 대문자가 먼저!
// 대소문자 무시 정렬
mixed.sort(String.CASE_INSENSITIVE_ORDER);
// → [apple, Banana, Cherry]3.5 LocalDate 의 자연 순서
LocalDate today = LocalDate.now();
LocalDate yesterday = today.minusDays(1);
LocalDate tomorrow = today.plusDays(1);
today.compareTo(yesterday); // 양수 (today > yesterday)
today.compareTo(tomorrow); // 음수 (today < tomorrow)
// 정렬
List<LocalDate> dates = Arrays.asList(
LocalDate.of(2025, 12, 31),
LocalDate.of(2024, 1, 1),
LocalDate.of(2025, 6, 15)
);
Collections.sort(dates);
// → [2024-01-01, 2025-06-15, 2025-12-31]3.6 Enum 의 자연 순서
public enum ShipmentStatus {
DRAFT, // ordinal = 0
PENDING, // ordinal = 1
ACTIVE, // ordinal = 2
COMPLETED, // ordinal = 3
CANCELLED // ordinal = 4
}
ShipmentStatus.DRAFT.compareTo(ShipmentStatus.ACTIVE);
// → 음수 (0 - 2 = -2)
// 정렬
List<ShipmentStatus> statuses = Arrays.asList(
ShipmentStatus.ACTIVE,
ShipmentStatus.DRAFT,
ShipmentStatus.COMPLETED
);
Collections.sort(statuses);
// → [DRAFT, ACTIVE, COMPLETED]→ 선언 순서가 곧 자연 순서.
3.7 자연 순서가 없는 경우
// 자연 순서가 의미 없는 클래스
public class Color {
private int r, g, b;
// RGB 색상 — 어떻게 비교?
// 자연 순서가 명확하지 않음
// → Comparable 구현 안 함
}
// 정렬 필요시 외부 Comparator
List<Color> colors = ...;
colors.sort(Comparator.comparingInt(c -> c.r)); // 빨강 강도
colors.sort(Comparator.comparingInt(c -> c.brightness())); // 밝기3.8 자기 점검 답변
자연 순서 (Natural Ordering) 의 의미는?
답:
-
정의:
- Comparable.compareTo 가 정의하는 순서
- 클래스에 내재된 정렬 기준
-
활용:
- Collections.sort(list)
- TreeMap, TreeSet
- Stream.sorted()
- PriorityQueue
-
예:
- Integer: 숫자 오름차순
- String: 사전순
- LocalDate: 시간순
- Enum: 선언 순서
-
없는 경우:
- 자연 순서가 의미 없으면 Comparable 구현 X
- 외부 Comparator 활용
4️⃣ compareTo 의 5가지 계약
4.1 5가지 계약
compareTo 의 5가지 계약:
1. 반사성 (Reflexivity)
x.compareTo(x) == 0
2. 대칭성 (Anti-symmetry)
x.compareTo(y) == -y.compareTo(x) 의 부호
3. 추이성 (Transitivity)
x.compareTo(y) > 0 && y.compareTo(z) > 0 => x.compareTo(z) > 0
4. 일관성 (Consistency)
변경 없으면 같은 결과
5. equals 일치 (권장, 강제 아님)
x.compareTo(y) == 0 <=> x.equals(y)4.2 반사성
// x.compareTo(x) 는 항상 0
@Override
public int compareTo(Person other) {
if (this == other) return 0; // 명시적
return Integer.compare(this.age, other.age);
}
Person p = new Person("Alice", 25);
p.compareTo(p); // 0 (반사성)4.3 대칭성 (Anti-symmetry)
// x.compareTo(y) 의 부호 == -y.compareTo(x) 의 부호
Person p1 = new Person("Alice", 25);
Person p2 = new Person("Bob", 30);
p1.compareTo(p2); // 음수 (예: -5)
p2.compareTo(p1); // 양수 (예: 5)
// 부호가 반대 ✓
// 위반 예
@Override
public int compareTo(Person other) {
if (this.age < other.age) return -1;
return 0; // ❌ this > other 도 0 반환
// 대칭성 위반: x.compareTo(y) = 0, y.compareTo(x) = -1
}4.4 추이성 (Transitivity)
// x.compareTo(y) > 0 && y.compareTo(z) > 0 => x.compareTo(z) > 0
Person p1 = new Person("Alice", 30);
Person p2 = new Person("Bob", 25);
Person p3 = new Person("Charlie", 20);
p1.compareTo(p2); // 양수 (30 > 25)
p2.compareTo(p3); // 양수 (25 > 20)
p1.compareTo(p3); // 양수 (30 > 20) ✓
// 위반 예 — 잘못된 로직
@Override
public int compareTo(Person other) {
// 복잡한 조건으로 추이성 깨짐 가능
}4.5 일관성
// 변경 없으면 같은 결과
@Override
public int compareTo(Person other) {
// ❌ 외부 상태 의존
return System.currentTimeMillis() % 2 == 0
? Integer.compare(age, other.age)
: -Integer.compare(age, other.age);
// 결과가 시간에 따라 다름
}
// ✓ 객체 자체 데이터만
@Override
public int compareTo(Person other) {
return Integer.compare(age, other.age);
}4.6 equals 일치 (권장)
// x.compareTo(y) == 0 <=> x.equals(y)
// 강제 아니지만 권장
// 일치하는 예
public class Person implements Comparable<Person> {
private String name;
private int age;
@Override
public int compareTo(Person other) {
return Integer.compare(age, other.age);
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Person)) return false;
return age == ((Person) obj).age;
// age 만 비교 — compareTo 와 일치
}
}
// 불일치 예 — 위험
public class BadPerson implements Comparable<BadPerson> {
private String name;
private int age;
@Override
public int compareTo(BadPerson other) {
return Integer.compare(age, other.age); // age 만
}
@Override
public boolean equals(Object obj) {
// name + age 비교 — compareTo 와 불일치
if (!(obj instanceof BadPerson)) return false;
BadPerson p = (BadPerson) obj;
return age == p.age && Objects.equals(name, p.name);
}
}
// 불일치의 결과
BadPerson p1 = new BadPerson("Alice", 25);
BadPerson p2 = new BadPerson("Bob", 25);
p1.compareTo(p2); // 0 (같음, age 만)
p1.equals(p2); // false (name 다름)
// TreeSet 동작
TreeSet<BadPerson> set = new TreeSet<>();
set.add(p1);
set.add(p2);
set.size(); // 1! (compareTo 가 0 이라 같다고 봄)
// HashSet 동작
HashSet<BadPerson> hashSet = new HashSet<>();
hashSet.add(p1);
hashSet.add(p2);
hashSet.size(); // 2 (equals 다르다고 봄)
// → 같은 두 객체가 다른 컬렉션에서 다른 동작4.7 BigDecimal 의 의도적 불일치
// BigDecimal 은 의도적으로 일관성 X
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");
a.compareTo(b); // 0 (값 같음)
a.equals(b); // false (scale 다름)
// HashSet
Set<BigDecimal> set = new HashSet<>();
set.add(a);
set.add(b);
set.size(); // 2 (equals 다름)
// TreeSet
Set<BigDecimal> tree = new TreeSet<>();
tree.add(a);
tree.add(b);
tree.size(); // 1! (compareTo 같음)
// → 일관성 권장이지만 BigDecimal 은 예외
// 사용 시 주의4.8 자기 점검 답변
compareTo 의 5가지 계약과 equals 와의 일관성은?
답:
1. 반사성: x.compareTo(x) == 0
2. 대칭성: 부호가 반대
3. 추이성: x > y, y > z → x > z
4. 일관성: 변경 없으면 같은 결과
5. equals 일치 (권장): compareTo == 0 ↔ equals == true
일관성 깨지면:
- TreeSet 과 HashSet 동작 다름
- 같은 객체가 다른 컬렉션에서 다른 크기
- 예: BadPerson (의도적 X), BigDecimal (의도적)
5️⃣ equals 와 compareTo 의 일관성
5.1 일관성의 정의
일관성 (Consistency):
x.compareTo(y) == 0 <=> x.equals(y) == true
권장:
- Comparable 의 javadoc 에서 강력 권장
- 강제 아니지만 일관성 깨지면 문제
문제:
- TreeMap, TreeSet 은 compareTo 사용
- HashMap, HashSet 은 equals + hashCode 사용
- 다른 동작 가능5.2 일관성의 효과
// 일관된 클래스
public class Money implements Comparable<Money> {
private BigDecimal amount;
private String currency;
@Override
public int compareTo(Money other) {
if (!currency.equals(other.currency)) {
throw new IllegalArgumentException();
}
return amount.compareTo(other.amount);
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Money)) return false;
Money m = (Money) obj;
return Objects.equals(currency, m.currency)
&& amount.compareTo(m.amount) == 0; // compareTo 사용
}
@Override
public int hashCode() {
return Objects.hash(currency, amount.stripTrailingZeros());
}
}
// 사용
Money m1 = new Money(new BigDecimal("10.00"), "USD");
Money m2 = new Money(new BigDecimal("10.0"), "USD");
m1.compareTo(m2); // 0 (값 같음)
m1.equals(m2); // true (compareTo 기반)
Set<Money> hashSet = new HashSet<>();
hashSet.add(m1);
hashSet.add(m2);
hashSet.size(); // 1 ✓ (일관성)
Set<Money> treeSet = new TreeSet<>();
treeSet.add(m1);
treeSet.add(m2);
treeSet.size(); // 1 ✓ (일관성)5.3 일관성 깨진 사례 — BigDecimal
// BigDecimal 은 일관성 X
BigDecimal a = new BigDecimal("100.00");
BigDecimal b = new BigDecimal("100.0");
a.compareTo(b); // 0 (값 같음)
a.equals(b); // false (scale 다름)
// 영향
Set<BigDecimal> hashSet = new HashSet<>();
hashSet.add(a);
hashSet.add(b);
hashSet.size(); // 2 (equals 다름)
Set<BigDecimal> treeSet = new TreeSet<>();
treeSet.add(a);
treeSet.add(b);
treeSet.size(); // 1 (compareTo 같음)
// 해결: stripTrailingZeros
BigDecimal a = new BigDecimal("100.00").stripTrailingZeros();
BigDecimal b = new BigDecimal("100.0").stripTrailingZeros();
a.equals(b); // true ✓5.4 일관성 검증
@Test
void testComparableEqualsConsistency() {
Person p1 = new Person("Alice", 25);
Person p2 = new Person("Alice", 25);
Person p3 = new Person("Bob", 25);
Person p4 = new Person("Alice", 30);
// 같은 객체
assertEquals(0, p1.compareTo(p2));
assertEquals(p1, p2);
// 다른 객체
assertTrue(p1.compareTo(p3) != 0 || !p1.equals(p3));
assertTrue(p1.compareTo(p4) != 0 || !p1.equals(p4));
// 일관성
assertTrue(
(p1.compareTo(p2) == 0) == p1.equals(p2)
);
}5.5 자기 점검 답변
equals 와 compareTo 의 일관성이 왜 중요한가?
답:
1. TreeSet vs HashSet 차이:
- TreeSet: compareTo 사용
- HashSet: equals + hashCode
- 일관성 깨지면 다른 동작
-
컬렉션 동작 불일치:
- 같은 객체 추가 시 size 다름
- contains 결과 다름
- 디버깅 어려움
-
권장 (강제 아님):
- BigDecimal 같은 예외 존재
- 명확한 의도가 있을 때만 깨기
-
검증:
- 단위 테스트
- 같은 필드 사용
6️⃣ 다중 필드 비교
6.1 다중 필드 비교의 필요
// 시나리오: Person 을 나이 우선, 같으면 이름순
public class Person implements Comparable<Person> {
private String name;
private int age;
// ❌ 단일 필드만
@Override
public int compareTo(Person other) {
return Integer.compare(age, other.age);
// 같은 나이는 임의 순서
}
}
// 개선 필요6.2 if 문 방식
@Override
public int compareTo(Person other) {
// 1. 나이 비교
int cmp = Integer.compare(this.age, other.age);
if (cmp != 0) return cmp;
// 2. 같으면 이름
return this.name.compareTo(other.name);
}6.3 더 우아한 방식 — Comparator.thenComparing
@Override
public int compareTo(Person other) {
return Comparator.<Person, Integer>comparing(p -> p.age)
.thenComparing(p -> p.name)
.compare(this, other);
}
// 또는 더 명확하게
private static final Comparator<Person> COMPARATOR =
Comparator.<Person>comparingInt(p -> p.age)
.thenComparing(p -> p.name);
@Override
public int compareTo(Person other) {
return COMPARATOR.compare(this, other);
}6.4 자바 표준의 String 다중 비교
// String.compareTo 는 사전순
// 같으면 길이로
// 같은 패턴의 사용자 구현
public class FullName implements Comparable<FullName> {
private String first;
private String last;
@Override
public int compareTo(FullName other) {
// last name 먼저
int cmp = last.compareTo(other.last);
if (cmp != 0) return cmp;
// 같으면 first name
return first.compareTo(other.first);
}
}
// 정렬 예
List<FullName> names = Arrays.asList(
new FullName("Alice", "Smith"),
new FullName("Bob", "Adams"),
new FullName("Alice", "Adams")
);
Collections.sort(names);
// 1. Alice Adams
// 2. Bob Adams
// 3. Alice Smith6.5 정렬 우선순위 변경
public class Shipment implements Comparable<Shipment> {
private int priority;
private LocalDateTime createdAt;
private String blNo;
@Override
public int compareTo(Shipment other) {
// 1. priority 높은 게 먼저 (내림차순)
int cmp = Integer.compare(other.priority, this.priority);
if (cmp != 0) return cmp;
// 2. 같으면 createdAt 빠른 게 먼저 (오름차순)
cmp = createdAt.compareTo(other.createdAt);
if (cmp != 0) return cmp;
// 3. 같으면 blNo
return blNo.compareTo(other.blNo);
}
}6.6 더 우아한 ILIC 구현
public class Shipment implements Comparable<Shipment> {
private int priority;
private LocalDateTime createdAt;
private String blNo;
private static final Comparator<Shipment> COMPARATOR =
Comparator.<Shipment>comparingInt(s -> -s.priority) // 내림차순
.thenComparing(s -> s.createdAt) // 오름차순
.thenComparing(s -> s.blNo);
@Override
public int compareTo(Shipment other) {
return COMPARATOR.compare(this, other);
}
}6.7 Objects.compare 활용
// Java 7+ Objects.compare
public static <T> int compare(T a, T b, Comparator<? super T> c) {
return (a == b) ? 0 : c.compare(a, b);
}
// 사용
@Override
public int compareTo(Person other) {
return Objects.compare(this, other, COMPARATOR);
}6.8 자기 점검 답변
다중 필드 비교의 우아한 방법은?
답:
1. if 문 방식 (단순):
int cmp = field1.compareTo(other.field1);
if (cmp != 0) return cmp;
return field2.compareTo(other.field2);-
Comparator.thenComparing (권장):
Comparator.comparing(Person::getAge) .thenComparing(Person::getName) -
정적 필드로 추출:
private static final Comparator<Person> COMP = ...; -
정렬 방향 조정:
.reversed() // 내림차순
7️⃣ TreeMap, TreeSet, Collections.sort 의 활용
7.1 TreeSet — 자동 정렬 Set
TreeSet<Integer> set = new TreeSet<>();
set.add(5);
set.add(2);
set.add(8);
set.add(1);
// 내부: [1, 2, 5, 8] — 자동 정렬
set.first(); // 1
set.last(); // 8
// 범위 검색
set.headSet(5); // [1, 2]
set.tailSet(5); // [5, 8]
set.subSet(2, 8); // [2, 5]
// 정렬된 순회
for (Integer n : set) {
System.out.println(n);
}
// 1, 2, 5, 87.2 TreeMap — 자동 정렬 Map
TreeMap<LocalDate, BigDecimal> dailySales = new TreeMap<>();
dailySales.put(LocalDate.of(2025, 1, 15), new BigDecimal("1000"));
dailySales.put(LocalDate.of(2025, 1, 1), new BigDecimal("500"));
dailySales.put(LocalDate.of(2025, 1, 10), new BigDecimal("750"));
// 키 기준 자동 정렬
dailySales.firstKey(); // 2025-01-01
dailySales.lastKey(); // 2025-01-15
// 범위 조회
dailySales.headMap(LocalDate.of(2025, 1, 10)); // [01-01]
dailySales.tailMap(LocalDate.of(2025, 1, 10)); // [01-10, 01-15]
// 순회 (정렬된 순서)
for (Map.Entry<LocalDate, BigDecimal> entry : dailySales.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}7.3 Collections.sort
List<Integer> list = new ArrayList<>(Arrays.asList(5, 2, 8, 1));
Collections.sort(list);
// list: [1, 2, 5, 8]
// List.sort 도 같음
list.sort(null); // null = 자연 순서
// Stream
List<Integer> sorted = list.stream().sorted().toList();7.4 PriorityQueue — 우선순위 큐
PriorityQueue<Integer> queue = new PriorityQueue<>();
queue.offer(5);
queue.offer(2);
queue.offer(8);
queue.offer(1);
queue.poll(); // 1 (가장 작음)
queue.poll(); // 2
queue.poll(); // 5
queue.poll(); // 8
// 내부 구조: heap
// add/remove: O(log n)
// peek: O(1)7.5 Collections.max / min
List<Integer> list = Arrays.asList(5, 2, 8, 1, 9, 3);
Integer max = Collections.max(list); // 9
Integer min = Collections.min(list); // 1
// 객체에도 적용
List<Person> people = ...;
Person youngest = Collections.min(people); // 자연 순서 사용
Person oldest = Collections.max(people);7.6 Collections.binarySearch
// 정렬된 List 에서 이진 검색
List<Integer> sorted = Arrays.asList(1, 2, 5, 8, 9);
int idx = Collections.binarySearch(sorted, 5);
// 2 (인덱스)
int idx2 = Collections.binarySearch(sorted, 4);
// -3 (음수 = 없음, 절댓값 - 1 = 삽입 위치)
// O(log n) — 빠른 검색
// 조건: 자연 순서로 정렬되어 있어야7.7 자연 순서 활용 종합
// ILIC 예
public class ShipmentService {
public List<Shipment> getOrderedShipments() {
List<Shipment> shipments = repository.findAll();
Collections.sort(shipments); // Comparable 활용
return shipments;
}
public Shipment getOldestShipment() {
return Collections.min(repository.findAll());
}
public TreeSet<Shipment> getShipmentsSortedSet() {
return new TreeSet<>(repository.findAll());
}
public TreeMap<LocalDate, List<Shipment>> getShipmentsByDate() {
return repository.findAll().stream()
.collect(Collectors.groupingBy(
Shipment::getCreatedAt,
TreeMap::new, // 자동 정렬
Collectors.toList()
));
}
}7.8 자기 점검 답변
Comparable 을 활용하는 자바 컬렉션 5가지는?
답:
1. TreeSet: 자동 정렬 Set
2. TreeMap: 키 자동 정렬 Map
3. PriorityQueue: 우선순위 큐 (힙)
4. Collections.sort: List 정렬
5. Collections.max/min/binarySearch: 검색
추가:
- Stream.sorted()
- Arrays.sort()
→ 자바 컬렉션의 정렬 + 검색의 토대.
8️⃣ 자바 표준의 Comparable 분석
8.1 Integer.compareTo
public final class Integer implements Comparable<Integer> {
@Override
public int compareTo(Integer other) {
return compare(this.value, other.value);
}
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
}특징:
- 안전한 비교 (오버플로우 X)
- 정적 메서드 활용
- -1, 0, 1 반환
8.2 String.compareTo
public final class String implements Comparable<String> {
@Override
public int compareTo(String other) {
int len1 = value.length;
int len2 = other.value.length;
int lim = Math.min(len1, len2);
// 1. 문자 비교
for (int i = 0; i < lim; i++) {
char c1 = value[i];
char c2 = other.value[i];
if (c1 != c2) {
return c1 - c2; // 문자 코드 차이
}
}
// 2. 모든 비교 후 길이 비교
return len1 - len2;
}
}특징:
- 문자별 비교
- 짧으면 길이 차이
- 사전순
8.3 LocalDate.compareTo
public final class LocalDate implements ChronoLocalDate {
@Override
public int compareTo(ChronoLocalDate other) {
if (other instanceof LocalDate) {
return compareTo0((LocalDate) other);
}
return ChronoLocalDate.super.compareTo(other);
}
private int compareTo0(LocalDate other) {
int cmp = (year - other.year);
if (cmp == 0) {
cmp = (month - other.month);
if (cmp == 0) {
cmp = (day - other.day);
}
}
return cmp;
}
}특징:
- 년 → 월 → 일 순서로 비교
- 다중 필드 비교의 모범
8.4 BigDecimal.compareTo
public class BigDecimal extends Number implements Comparable<BigDecimal> {
@Override
public int compareTo(BigDecimal other) {
// scale 무관 비교
if (scale == other.scale) {
long s1 = intCompact;
long s2 = other.intCompact;
if (s1 != INFLATED && s2 != INFLATED) {
return Long.compare(s1, s2);
}
}
// 복잡한 scale 정규화 후 비교
// ...
}
}
// equals 와 의도적으로 다름
// equals: scale 도 비교
// compareTo: 값만 비교8.5 Character.compareTo
public final class Character implements Comparable<Character> {
@Override
public int compareTo(Character other) {
return compare(this.value, other.value);
}
public static int compare(char x, char y) {
return x - y;
// char 는 unsigned 16-bit, 오버플로우 안전
}
}8.6 Enum.compareTo
public abstract class Enum<E extends Enum<E>> implements Comparable<E> {
@Override
public final int compareTo(E other) {
Enum<?> first = this;
Enum<?> second = other;
if (first.getDeclaringClass() != second.getDeclaringClass()) {
throw new ClassCastException();
}
return first.ordinal() - second.ordinal();
}
}
// final 이라 override 불가
// 선언 순서로 비교8.7 비교 종합
| 클래스 | 비교 기준 | 특이사항 |
|---|---|---|
| Integer | 값 | 안전한 compare |
| Long | 값 | 안전한 compare |
| Double | 값 | NaN 처리 |
| String | 문자 + 길이 | 사전순 |
| LocalDate | 년/월/일 | 다중 필드 |
| BigDecimal | 값 (scale 무관) | equals 와 불일치 |
| Character | char 값 | unsigned |
| Enum | ordinal | final, 선언 순서 |
8.8 자기 점검 답변
자바 표준 Comparable 구현의 모범 패턴은?
답:
1. Integer.compareTo:
- 정적
compare메서드 - 안전한 비교 (오버플로우 X)
-
String.compareTo:
- 문자별 비교
- 길이 차이로 마무리
-
LocalDate.compareTo:
- 년 → 월 → 일 다중 필드
- if 문 방식
-
BigDecimal.compareTo:
- 의도적으로 equals 와 불일치
- scale 무관 값 비교
-
Enum.compareTo:
- final (override 불가)
- ordinal 기반
→ 모두 안전성 + 명확성.
9️⃣ 면접 + 자기 점검
9.1 면접 단골 질문 매핑
| Q | 핵심 답변 |
|---|---|
| Comparable 정의? | java.lang, 단일 메서드 |
| compareTo 반환값? | 음수/0/양수 (부호만 중요) |
| 자연 순서? | Comparable 이 정의하는 순서 |
| compareTo 5가지 계약? | 반사/대칭/추이/일관/equals 일치 |
| equals 와 일관성? | TreeSet vs HashSet 동작 일치 |
| BigDecimal 의 예외? | scale 무관 compareTo |
| 다중 필드 비교? | if 문 또는 thenComparing |
| Integer.compare 사용 이유? | 오버플로우 안전 |
| TreeMap, TreeSet 활용? | Comparable 자동 사용 |
| Enum compareTo? | ordinal, final |
| Comparable 인스턴스화? | 불가 (인터페이스) |
9.2 자기 점검 체크리스트
기본 이해
- Comparable 인터페이스 정의
- compareTo 의 반환값
- 자연 순서의 의미
- 자바 표준의 Comparable 구현 (Integer, String, ...)
계약
- 5가지 계약 (반사/대칭/추이/일관/equals)
- equals 와의 일관성
- BigDecimal 의 예외
- 위반 시 결과
구현
- 단일 필드 비교
- 다중 필드 비교 (if 문)
- 다중 필드 비교 (thenComparing)
- Integer.compare 활용
활용
- Collections.sort
- TreeSet, TreeMap
- PriorityQueue
- Stream.sorted
- Collections.max/min/binarySearch
9.3 추가 심화 질문
Q1: Comparable 의 T 는 보통 자기 자신인 이유?
답:
- 자기 타입과 비교가 일반적
Person implements Comparable<Person>- 다른 타입과 비교는 드물고 복잡 (Child implements Comparable)
- 자기 타입이 가장 자연스러운 의미
Q2: compareTo 가 일관성 깨지면?
답:
- 정렬 결과 예측 불가
- TreeSet 의 동작 불안정
- 같은 정렬을 두 번 했을 때 다른 결과
- 디버깅 매우 어려움
Q3: Comparable 과 함수형 인터페이스?
답:
- Comparable 은 함수형 인터페이스 X
- 추상 메서드 1개 (조건 충족)
- 하지만 람다로 잘 안 씀:
- 클래스의 정체성에 의존
- 람다 = 익명 함수, 클래스 정체성 X
- Comparator 가 함수형 인터페이스로 권장
Q4: compareTo 의 결과를 어떻게 사용?
답:
int cmp = a.compareTo(b);
if (cmp < 0) { ... } // a < b
if (cmp == 0) { ... } // a == b
if (cmp > 0) { ... } // a > b
// 또는 부호만
int sign = Integer.signum(cmp);Q5: Comparable 을 구현 안 하면?
답:
- Collections.sort(list) → ClassCastException
- TreeSet add → ClassCastException
- 외부 Comparator 필요
- Comparator.comparing 또는 직접 구현
// Comparable 없을 때
public class Color { ... }
List<Color> colors = ...;
Collections.sort(colors); // ❌ ClassCastException
// 해결: 외부 Comparator
colors.sort(Comparator.comparingInt(c -> c.brightness()));🎯 핵심 요약 — 3줄 정리
1. Comparable
- "자기 자신의 비교 기준" 정의
- compareTo: 음수/0/양수
- 자연 순서 (Natural Ordering)
2. 5가지 계약
- 반사/대칭/추이/일관
- equals 와의 일관성 (권장)
- BigDecimal 은 예외
3. 활용
- Collections.sort, TreeSet, TreeMap
- PriorityQueue, binarySearch
- Integer.compare 로 안전한 비교
📚 다음으로...
Unit 6.3 — Comparator 의 외부 비교
이번 Unit에서 Comparable 을 봤다면, 다음은 Comparator 의 정밀.
- Comparator 의 정의
- 함수형 인터페이스로서의 활용
- comparing, thenComparing, reversed
- naturalOrder, reverseOrder
- null 처리 (nullsFirst, nullsLast)
Phase 6 진행 상황
🚀 Phase 6 — 객체 비교
✅ Unit 6.1 equals 와 hashCode 의 계약
✅ Unit 6.2 Comparable<T> 의 자연 순서 ← 여기
⏭ Unit 6.3 Comparator<T> 의 외부 비교
⏭ Unit 6.4 비교의 종합 활용 (마스터 깊이)3주차 누적 진행
✅ Phase 1 — Pass by Value (1.1 ~ 1.3 완주)
✅ Phase 2 — 컬렉션 프레임워크 (2.1 ~ 2.6 완주)
✅ Phase 3 — 해시의 원리 (3.1 ~ 3.4 완주)
✅ Phase 4 — 추상화의 두 도구 (4.1 ~ 4.4 완주)
✅ Phase 5 — 제네릭과 와일드카드 (5.1 ~ 5.5 완주)
🚀 Phase 6 — 객체 비교 (2/4 진행)
총: 24/43 Unit 작성 (약 56%)
Software Developer