Jusung Kim

Android Developer

6 분 소요

kotlin03_main.jpg

3.1 코틀린에서 컬렉션 만들기

컬렉션을 만드는 방법은 자바와 비슷하다.

val set = hashSetOf(1, 7, 53)
val list = arrayListOf(1, 7, 53)
val map = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

코틀린이 자체 컬렉션을 제공하지 않는 이유는 뭘까?

표준 자바 컬렉션을 활용하면 자바 코드와 상호작용하기가 훨씬 더 쉽기 때문이다.

때문에 자바에서 코틀린 함수를 호출하거나 코틀린에서 자바 함수를 호출할 때 자바와 코틀린 컬렉션을 서로 변환할 필요가 없다. 하지만 코틀린에서는 자바보다 더 많은 기능을 쓸 수 있다.

fun main(args: Array<String>) {
    val strings = listOf("first", "second", "fourteenth")
    println(strings.last()) // 리스트의 마지막 원소를 가져온다. 
    val numbers = setOf(1, 14, 2)
    println(numbers.max()) // 컬렉션에서 최댓값을 가져온다. 
}

3.2 함수를 호출하기 쉽게 만들기

자바 컬렉션에는 컬렉션에는 디폴트 toString 구현이 들어있다.

val list = listOf(1, 2, 3)
println(list)
// [1, 2, 3]

디폴트 구현과 달리 (1; 2; 3)처럼 원소 사이를 세미콜론으로 구분하고 괄호로 리스트를 둘러싸고 싶다면 어떻게 해야 할까?

코틀린에는 이런 요구 사항을 처리할 수 있는 함수가 표준 라이브러리에 이미 들어있다.

처음에는 함수 선언을 간단하게 만들수 있게 코틀린이 지원하는 여러 기능을 사용하지 않고 함수를 직접 구현한다.

그 후 좀 더 코틀린답게 같은 함수를 다시 구현한다.

fun <T> joinToString(
        collection: Collection<T>,
        separator: String = ";",
        prefix: String = "(",
        postfix: String = ")"
): String {

    val result = StringBuilder(prefix)

    for ((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

fun main(args: Array<String>) {
    val list = listOf(1, 2, 3)
    println(joinToString(list, "; ", "(", ")"))
    println(joinToString(collection = list, separator = ";", prefix = "(", postfix = ")"))
    println(joinToString(list))
    println(joinToString(list, "; "))
}

이 함수는 제네릭하다. 즉, 이 함수는 어떤 타입의 값을 원소로 하는 컬렉션이든 처리할 수 있다.

제네릭 문법은 자바와 비슷하다.

3.2.1 이름 붙인 인자

해결하고픈 첫 번째 문제는 함수 호출 부분의 가독성이다.

joinToString(collection," "," "," ")

인자로 전달한 각 문자열이 어떤 역할을 하는지 구분할 수 있는가?

이런 문제는 특히 불리언 플래그 값을 전달해야 하는 경우 흔히 발생한다.

이를 해결하기 위해 일부 자바 코딩 스타일에서는 enum타입을 사용하거나 주석을 사용하라고 권장한다.

코틀린에서는 더 잘 할 수 있다.

joinToString(collection,separator = " ", prefix = " ", postfix = " ")

코틀린으로 작성한 함수를 호출할 때는 함수에 전달하는 인자 중 일부(전부)의 이름을 명시할 수 있다.

3.2.2 디폴트 파라미터 값

자바에서 일부 클래스에서 오버로딩한 메소드가 너무 많아진다는 문제가 있다.

코틀린에서는 함수 선언에서 파라미터의 디폴트 값을 지정할 수 있으므로 이런 오버로드 중 상당수를 피할 수있다.

fun <T> joinToString(
        collection: Collection<T>,
        separator: String = ";",
        prefix: String = "(",
        postfix: String = ")"
): String { //디폴트 값이 지정된 파라미터 값

joinToString(list,",","","")
joinToString(list)//separator,prefix,postfix 생략
joinToString(list,";")//separator를 ";"로 지정,prefix,postfix 생략

일반 호출 문법을 사용하려면 함수를 선언할 때와 같은 순서로 인자를 지정해야한다.

그런 경우 일부를 생략하면 뒷부분의 인자들이 생략된다.

이름 붙인 인자를 사용하는 경우 지정하고 싶은 인자의 이름을 붙여 순서와 관계없이 지정할 수 있다.

joinToString(list,postfix=";",prefix="#")

3.2.3 정적인 유틸리티 클래스 없애기: 최상위 함수와 프로퍼티

기존 코드와 코틀린 코드를 자연스럽게 통합하는 것은 코틀린의 핵심 목표 중 하나다.

이런 기존 자바 API를 재작성하지 않고도 코틀린이 제공하는 여러 편리한 기능을 사용할 수 는 없을까?

3.3 메소드를 다른 클래스에 추가: 확장 함수와 확장 프로퍼티

바로 확장 함수가 그런 역할을 해줄 수 있다.

개념적으로 확장 함수는 단순하다. 확장 함수는 어떤 클래스의 멤버 메소드인 것처럼 호출할 수 있지만 그 클래스의 밖에 선언된 함수다.

문자열의 마지막 문자를 돌려주는 확장 메소드를 추가해보자

package strings
fun String.lastChar(): Char = this.get(this.length - 1)

확장 함수를 만들려면 추가하려는 함수 이름 앞에 그 함수가 확장할 클래스의 이름을 덧붙이기만 하면 된다.

kotlin3_1.jpg

클래스 이름을 수신 객체 타입(receiver type)이라 부르며,

확장 함수가 호출되는 대상이 되는 값(객체)을 수신 객체(receiver object)라고 부른다.

println("Kotlin".lastChar())

// String = 수신 객체 타입
// "Kotlin" = 수신 객체

확장 함수는 클래스 안에서 정의한 메소드와 달리 확장 함수 안에서는 클래스 내부에서만 사용할 수 있는 비공개(private) 멤버나 보호된(protected) 멤버를 사용할 수 없다.

3.3.1 임포트와 확장 함수

확장 함수를 사용하기 위해서는 그 함수를 다른 클래스나 함수와 마찬가지로 임포트해야만 한다.

확장 함수를 임포트 없이 사용한다면 동일한 이름의 확장 함수와 충돌할 수도 있기 때문에 임포트로 어떤 확장함수인지 명시해 주어야 한다.

import strings.lastChar // 명시적으로 사용
import strings.* // * 사용 가능
import strings.lastChar as last // as 키워드를 사용 가능

3.3.2 자바에서 확장 함수 호출

자바에서 확장 함수를 사용하기도 편하다. 단지 정적 메소드를 호출하면서 첫 번째 인자로 수신 객체를 넘기기만 하면 된다.

다른 최상위 함수와 마찬가지로 확장 함수가 들어있는 자바 클래스 이름도 확장 함수가 들어있는 파일 이름에 따라 결정된다.

따라서 확장 함수를 StringUtil.kt 파일에 정의했다면 다음과 같이 호출할 수 있다.

char c = StringUtilKt.lastChar("java");

3.3.3 확장 함수로 유틸리티 함수 정의

이제 joinToString 함수의 최종 버전을 만들자.

이제 이 함수는 코틀린 하이브러리가 제공하는 함수와 거의 같아졌다.

fun <T> Collection<T>.joinToString(
        separator: String = ", ",
        prefix: String = "",
        postfix: String = ""
): String {
    val result = StringBuilder(prefix)

    for ((index, element) in this.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

fun main(args: Array<String>) {
    val list = arrayListOf(1, 2, 3)
    println(list.joinToString(" "))
}

확장 함수는 단지 정적 메소드 호출에 대한 문법적인 편의일 뿐이다.

그래서 클래스가 아닌 더 구체적인 타입을 수신 객체 타입으로 지정할 수도 있다.

3.3.4 확장 함수는 오버라이드할 수 없다

확장 함수는 클래스의 일부가 아니다. 확장 함수는 클래스 밖에 선언된다.

이름과 파라미터가 완전히 같은 확장 함수를 기반 클래스와 하위 클래스에 대해 정의해도

실제로는 확장 함수를 호출할 때 수신 객체로 지정한 변수의 정적 타입에 의해 어떤 확장함수가 호출될지 결정되지, 그 변수에 저장된 객체의 동적인 타입에 의해 확장 함수가 결정되지 않는다.

💡 노트

어떤 클래스를 확장한 함수와 그 클래스의 멤버 함수의 이름과 시그니처가 같다면 확장 함수가 아니라 멤버 함수가 호출된다(멤버 함수의 우선순위가 더 높다). 클래스의 API를 변경할 경우 항상 이를 염두에 둬야 한다.

3.3.5 확장 프로퍼티

확장 프로퍼티를 사용하면 기존 클래스 객체에 대한 프로퍼티 형식의 구문으로 사용할 수 있는 API를 추가할 수 있다.

프로퍼티라는 이름으로 불리기는 하지만 상태를 저장할 적절한 방법이 없기 때문에 실제로 확장 프로퍼티는 아무 상태도 가질 수 없다.

val String.lastChar: Char
    get() = get(length -1)

뒷받침하는 필드가 없어서 기본 게터 구현을 제공할 수 없으므로 최소한 게터는 꼭 정의를 해야 한다.

마찬가지로 초기화 코드에서 계산한 값을 담을 장소가 전혀 없으므로 초기화 코드도 쓸 수 없다.

var StringBuilder.lastChar: Char
    get() = get(length - 1)
    set(value: Char) {
        this.setCharAt(length - 1, value)
    }

fun main(args: Array<String>) {
    println("Kotlin".lastChar)
    val sb = StringBuilder("Kotlin?")
    sb.lastChar = '!'
    println(sb)
}

3.4 컬렉션 처리: 가변 길이 인자, 중위 함수 호출, 라이브러리 지원

  • vararg 키워드를 사용하면 호출 시 인자 개수가 달라질 수 있는 함수를 정의할 수 있다.
  • 중위(infix)함수 호출 구문을 사용하면 인자가 하나뿐인 메소드를 간편하게 호출할 수 있다.
  • 구조 분해 선언(destructuring declaration)을 사용하면 복합적인 값을 분해해서 여러 변수에 나눠 담을 수 있다.

3.4.1 자바 컬렉션 API 확장

코틀린 컬렉션은 자바와 같은 클래스를 사용하지만 더 확장된 API를 제공한다고 했다.

그 이유는 last와 max 등 모두 확장 함수로 정의 되었기 때문이다.

코틀린 표준 라이브러리를 모두 다 알 필요는 없다.

컬렉션이나 다른 객체에 대해 사용할 수 있는 메소드나 함수가 무엇인지 궁금할 때마다 IDE의 코드 완성 기능을 통해 그런 메소드나 함수를 살펴볼 수 있다.

IDE가 표시해주는 목록에서 원하는 함수를 선택하기만 하라

3.4.2 가변 인자 함수: 인자의 개수가 달라질 수 있는 함수 정의

가변 길이 인자(varargs)는 메소드를 호출할 때 원하는 개수만큼 값을 인자로 넘기면 자바 컴파일러가 배열에 그 값들을 넣어주는 기능이다.

코틀린의 가변 길이 인자도 자바와 비슷하다. 다만 문법이 조금 다르다. 타입 뒤에 …를 붙이는 대신 코틀린에서는 파라미터 앞에 varag 변경자를 붙인다.

public fun <T> listOf(vararg elements: T): List<T> = if {
    (elements.size > 0) elements.asList()
} else {
    emptyList()
}

fun main(args: Array<String>) {
    val list = listOf("one", "two", "eight")
}

이미 배열에 들어있는 원소를 가변 길이 인자로 넘길 때도 코틀린과 자바 구문이 다르다.

자바에서는 배열을 그냥 넘기면 되지만 코틀린에서는 배열을 명시적으로 풀어서 배열의 각 원소가 인자로 전달되게 해야 한다.

기술적으로는 스프레드(spread) 연산자가 그런 작업을 해준다.

fun main(args: Array<String>) {
    val list = listOf("args: ", *args)
}

3.4.3 값의 쌍 다루기: 중위 호출과 구조 분해 선언

맵을 만들려면 mapOf 함수를 사용한다.

val map = mapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

여기서 to라는 단어는 코틀린 키워드가 아니다.

이 코드는 중위 호출이라는 특별한 방식으로 to라는 일반 메소드를 호출한 것이다.

중위 호출 시에는 수신 객체와 유일한 메소드 인자 사이에 메소드 이름을 넣는다.

1.to("one") // "to" 메소드를 일반적인 방식으로 호출함
1 to "one" // "to" 메소드를 중위 호출 방식으로 호출함

함수(메소드)를 중위 호출에 사용하게 허용하고 싶으면 infix 변경자를 함수(메소드) 선언 앞에 추가해야 한다.

public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

val (number, name) = 1 to "one"

이런 기능을 구조 분해 선언이라고 부른다.

Pair 인스턴스 외 다른 객체에도 구조 분해를 적용할 수 있다. 예를 들어 key와 value라는 두 변수를 맵의 원소를 사용해 초기화할 수 있다.

for ((index, element) in collection.withIndex()) {
    println("$index: $element")
}

참조

드미트리 제메로프 · 스베트라나 이사코바, 『Kotlin IN ACTION』, 오현석 옮김, 에이콘(2017), P103-129.

카테고리:

업데이트:

참고