[Kotlin] 비교 연산자 오버로딩

Kotlin in Action 을 공부하고 Effective kotlin 의 내용을 조금 참조하여 정리한 글입니다.

코틀린에서는 산술 연산자와 마찬가지로 원시 타입 값뿐 아니라 모든 객체에 대해 비교 연산을 수행할 수 있다.

• 자바에서는 객체 비교 시 equals 나 compareTo 를 호출해야 함
• 코틀린에서는 == 비교 연산자를 오버로딩하여 사용 가능

이번에는 비교 연산자를 지원하는 convention(관례) 를 살펴보자.

동등성 연산자: equals

코틀린은 == 연산자 호출을 equals 메서드 호출로 컴파일한다.

이는 다른 산술 연산자 오버로딩처럼 convention 을 적용한 것이다.

!= 연산자를 사용하는 식도 equals 호출로 컴파일된다. (비교 결과를 뒤집은 값을 결과 값으로)

== 와 != 는 내부에서 인자가 null 인지 검사하므로 다른 연산과 달리 nullable 값에도 적용할 수 있다.

• a == b → a 가 null 이 아니면 a.equals(b) 를 호출.
  • a 가 null 이면 b 도 null 일 때만 true 리턴

equals 메서드 구현하기

kotlin

닫기 줄바꿈

class Point(val x: Int, val y: Int) {
    override fun equals(other: Any?): Boolean {
        if (other === this) return true // 최적화: 파라미터가 this 와 같은 객체인지 확인
        if (other !is Point) return false // 파라미터 타입 검사
        return other.x == x && other.y == y // Point 로 smart cast 해서 x 와 y 프로퍼티에 접근
    }
}

assert(Point(10, 20) == Point(10, 20))
assert(Point(10, 20) != Point(5, 5))
assert(null == Point(1, 2))

•  식별자 비교 연산자(===)를 사용해 equals 의 파라미터가 수신 객체와 같은지 살펴본다.
• 식별자 비교 연산자는 자바 == 연산자와 같다.
• equals 를 구현할 때는 === 를 사용해서 자기 자신과의 비교를 최적화하는 경우가 많다.
• === 는 오버로딩할 수 없다.

이미 Any 의 equals 에는 operator 가 붙어 있다.

kotlin

닫기 줄바꿈

public open class Any {
    public open operator fun equals(other: Any?): Boolean
    // ...
}

Any 에 이미 정의된 메서드를 override 하는 것이므로 따로 operator 를 붙이지 않아도 된다.

또한 Any 에서 상속받은 equals 가 확장 함수보다 우선순위가 높기 때문에 equals 를 확장 함수로 정의할 수 없다.

!= 호출은 equals 메서드 호출로 바뀌며, 컴파일러는 equals 의 리턴 값을 반전시켜서 돌려준다.

우리가 따로 != 을 처리하기 위해 해야 할 일은 없다.

순서 연산자: compareTo

자바에서 비교를 수행하는 클래스는 Comparable 인터페이스를 구현해야 한다.

자바는 > 혹은 < 연산자로는 원시 타입의 값만 비교할 수 있다.

다른 모든 타입은 element1.compareTo(element2) 처럼 명시적으로 써야 한다.

Comparable 에 들어있는 compareTo 메서드는 한 객체와 다른 객체의 크기를 비교해 정수로 나타내준다. (이 메서드와 관련된 설명)

java

닫기 줄바꿈

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

 

 

 코틀린도 똑같은 Comparable 인터페이스를 지원한다.

코틀린은 Comparable 인터페이스 안에 있는 compareTo 메서드를 호출하는 convention 을 제공한다.

kotlin

닫기 줄바꿈

public interface Comparable<in T> {
    public operator fun compareTo(other: T): Int
}

 따라서 비교 연산자 <,>,<=,>= 는 compareTo 호출로 컴파일된다.

Comparable 인터페이스의 compareTo 에 operator 가 이미 붙어 있다.

 compareTo 는 Int 를 리턴한다.

 

compareTo 메서드를 Person 에 구현하기

kotlin

닫기 줄바꿈

class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int =
        compareValuesBy(this, other, Person::lastName, Person::firstName) // 인자로 받은 함수를 차레로 호출하면서 값 비교
}

val p1 = Person("Alice", "Smith")
val p2 = Person("Bob", "Johnson")
assertFalse { p1 < p2 }

 여기서 정의한 Person 객체의 Comparable 인터페이스는 코틀린 뿐 아니라 자바 쪽에서도 사용할 수 있다.

 

compareValuesBy 함수는 두 객체와 여러 비교 함수를 인자로 받는다. 

첫 번째 비교 함수에 두 객체를 넘겨서 두 객체가 같지 않다는 결과가 나오면 값을 즉시 리턴하고, 두 객체가 같다는 결과가 나오면, 두 번째 비교 함수를 통해 두 객체를 비교하는 식으로 모두 비교한다.

각 비교함수는 람다나 프로퍼티/메서드 참조일 수 있다.

 

필드를 직접 비교하면 코드는 더 복잡해지지만, 비교 속도는 훨씬 더 빨라진다.

처음에는 성능에 신경 쓰지 말고 이해하기 쉽고, 간결하게 코딩하자.
나중에 성능이 문제가 되면 성능을 개선하자.

 

Comparable 인터페이스를 구현하는 모든 자바 클래스를 코틀린에서는 간결한 연산자 구문으로 비교할 수 있다.

즉, 비교 연산자를 자바 클래스에 대해 사용하기 위해 특별히 확장 메서드를 만들 필요는 없다.

compareTo 규약을 지켜라

compareTo 는 아래와 같이 동작해야 한다.

• 비대칭적 동작
  • a >= b 이고, b >= a 라면, a == b 여야 한다.
    비교와 동등성 비교에 어떠한 관계가 있어야하며, 서로 일관성이 있어야 한다.
• 연속적 동작
  • a >= b 이고 b >= c 라면, a >= c 여야 한다.
    마찬가지로 a > b 이고, b > c 라면 a > c 여야 한다.
    이러한 동작을 하지 못하면, 원소 정렬이 무한 loop 에 빠질 수 있다.
• 코넥스적 동작(connex relation)
  • 두 원소는 어떤 확실한 관계를 가져야 한다.
    즉, a >= b 또는 b >= a 중, 적어도 하나는 항상 true 여야 한다.
    두 원소 사이에 관계가 없으면, 퀵 정렬과 삽입 정렬 등의 정렬 알고리즘을 사용할 수 없다.
    대신 위상 정렬(topological sort) 와 같은 정렬 알고리즘만 사용할 수 있다.

compareTo 를 따로 정의하지 않아도 되는 경우

코틀리에서는 일반적으로 어떤 프로퍼티 하나를 기반으로 순서를 지정하는 것으로 충분하다.

 

sortedBy: surname 프로퍼티를 기반으로 정렬하는 예

kotlin

닫기 줄바꿈

data class User(val name: String, val surname: String)

val names = listOf(User("Alice", "Smith"), User("Bob", "Johnson"))
val sorted = names.sortedBy { it.surname }
assert(sorted == listOf(User("Bob", "Johnson"), User("Alice", "Smith")))

 그렇다면 여러 프로퍼티를 기반으로 정렬해야 한다면 어떻게 할까?

그럴 때는 sortedWith 함수를 사용하면 된다.

compareBy 를 활용해서 comparator(비교기)를 만들어서 사용한다.

 

sortedWith: surname 으로 정렬하고, 같다면 name 까지 비교해서 정렬하는 예

kotlin

닫기 줄바꿈

val names = listOf(User("Alice", "Smith"), User("Bob", "Smith"))
val sorted = names.sortedWith(compareBy({ it.surname }, { it.name }))
assert(sorted == listOf(User("Alice", "Smith"), User("Bob", "Smith")))

 위와 달리 User 가 Comparable<User> 를 구현하는 형태로 만들 수도 있다.

특정 프로퍼티를 기반으로 정렬하게 하면 된다.

 

예를 들어 문자열은 알파벳과 숫자 등의 순서가 있다.

그래서 내부적으로 Comparable<String> 을 구현하고 있다.

일반적으로 텍스트는 알파벳과 숫자 순서로 정렬해야 하는 경우가 많아서 유용하다.

하지만 단점도 있다.

예를 들어 직관적이지 않은 부등호 기호로 두 문자열을 작성하는 코드는 이해하는 데 약간 시간이 걸린다.

그래서 Effective kotlin 에서는 아래처럼 하지 말라고 권고한다.

kotlin

닫기 줄바꿈

// 이렇게 하지 말라고 권고함
println("Kotlin" > "Java") // true

 

측정 단위, 날짜, 시간 등의 객체는 자연스러운 순서를 갖는다.

만약 객체가 자연스러운 순서인지 확실하지 않다면 Comparable 을 바로 구현하지 말고 comparator(비교기) 를 사용하자.

이를 자주 사용한다면, 클래스에 동반 객체로 만들어 두는 것이 좋다.

 

companion object 를 사용하여 comparator 만들어두기

kotlin

닫기 줄바꿈

data class User(val name: String, val surname: String) {
    // ...
    companion object {
        val DISPLAY_ORDER = compareBy(User::surname, User::name)
    }
}

val names = listOf(User("Alice", "Smith"), User("Bob", "Smith"))
val sorted = names.sortedWith(User.DISPLAY_ORDER)
assert(sorted == listOf(User("Alice", "Smith"), User("Bob", "Smith")))

 compareTo 구현하기

compareTo 를 구현할 때 유용한 최상위 함수가 있다.

• compareValues: 두 값을 단순하게 비교하기만 하는 경우

kotlin

닫기 줄바꿈

class User1(val name: String, val surname: String) : Comparable<User> {
    override fun compareTo(other: User): Int = compareValues(surname, other.surname)
}

• compareValuesBy: 더 많은 값을 비교하거나 selector(선택기)를 활용해서 비교하고 싶은 경우

kotlin

닫기 줄바꿈

class User2(val name: String, val surname: String) : Comparable<User2> {
    override fun compareTo(other: User2): Int = compareValuesBy(this, other, { it.surname }, { it.name })
}

 이 compareValuesBy 함수는 위에서도 사용했다.

compareValuesBy 함수는 사실 내부적으로 compareValues 를 for 문 을 돌면서 여러 번 실행하는 식으로 구현되어 있다.

 

compareTo 함수는 아래와 같은 값을 리턴해야 한다.

• 0: 수신 객체(receiver)와 other 가 같은 경우
• 양수: 수신 객체가 other 보다 큰 경우
• 음수: 수신 객체가 other 보다 작은 경우

이를 구현한 뒤에는 이 함수가 비대칭적 동작, 연속적 동작, 코넥스적 동작을 하는지 확인하자!