람다

람다 식과 멤버 참조

람다 식

람다는 함수를 값처럼 다루어 코드를 함수에 넘기거나 변수에 저장하기 쉽게 해준다.
가장 간단한 람다 식은 아래와 같다. -> 이전 부분은 파라미터 목록을 나타내고 -> 이후 부분은 본문을 나타낸다. 항상 중괄호로 감싸진다.

{ x: Int, y: Int -> x + y }

람다 식은 변수에 저장하거나 직접 호출할 수 있다.

val sum = { x: Int, y: Int -> x + y }
val result = sum(1, 2)

val result = { x: Int, y: Int -> x + y }(1, 2)

run에 람다를 인자로 넣어 실행시킬 수도 있다.

run { println("hello") }

함수 호출 시 맨 마지막 인자가 람다식이라면 람다를 괄호 밖으로 꺼낼 수 있다.
람다가 유일한 인자라면 빈 괄호를 없애도 된다.
일반적인 경우 파라미터 타입을 생략할 수 있다. 단, 람다식을 변수에 할당한다면 파라미터 타입을 생략하면 안된다.
람다의 파라미터가 하나뿐이고 타입을 컴파일러가 추론할 수 있다면 디폴트 파라미터 이름인 it를 사용할 수 있다. 단, 람다가 중첩되는 경우 등에는 파라미터가 어떤 람다에 속했는지 알기 어려우므로 직접 람다 파라미터를 명시해야 한다.

// 기본 형태
people.maxBy({ p: Person -> p.age })
// 람다를 외부로 분리
people.maxBy() { p: Person -> p.age }
// 빈 괄호 제거
people.maxBy { p: Person -> p.age }
// 파라미터 타입 생략
people.maxBy { p -> p.age }
// it 사용
people.maxBy { it.age }

아래는 함수 인자로 람다를 넣는 예시이다.

val people = listOf(Person("Alice", 21), Person("Bob", 32))

// 이름 붙인 인자를 사용하기
val result = people.joinToString(separator = " ", tramsform = { p: Person -> p.name })

// 람다를 함수 인자 외부로 분리하기
val result = people.joinToString(" ") { p: Person -> p.name }

본문이 여러 문장으로 구성된 람다식의 경우 맨 마지막 식이 람다의 결과값이 된다.

val sum = { x: Int, y: Int ->
    println("computing...")
    x + y
}

val result = println(sum(1, 2))

컬렉션에서 활용

사람 정보를 담은 리스트에서 나이를 기준으로 가장 많은 사람을 구하려면 for문을 순회할 수 있다. 람다와 코틀린에서 제공되는 maxBy 함수를 사용하면 동일한 내용을 간단히 구현할 수 있다.
- it 는 컬렉션의 원소를 인자로 받았을 때를 의미한다.

// for문 사용
val people = listOf(Person("Alice", 21), Person("Bob", 32))
var maxAge = 0
var theOldest: Person? = null
for (person in people) {
    if (person.age > maxAge) {
        maxAge = person.age
        theOldest = person
    }
}
println(theOldest)

// 람다와 maxBy 함수 사용
println(people.maxBy({ p: Persion -> p.age }))
println(people.maxBy { it.age })

// 멤버 참조와 maxBy 함수 사용
println(people.maxBy(Person::age))

현재 영역의 변수 접근

자바의 익명 클래스에서는 익명 클래스를 정의한 메서드의 로컬 변수를 사용할 수 있듯이, 람다에서도 람다를 정의한 함수의 파라미터, 로컬 변수를 사용할 수 있다.

fun printMessagesWithPrefix(messages: Collection<String>, prefix: String) {
    messages.forEach {
        println("$prefix $it")
    }
}

자바와 달리 파이널 변수가 아닌 로컬 변수여도 접근이 가능하다.
함수 내에 정의된 로컬 변수의 생명 주기는 함수가 반환되면 끝나지만, 람다에서 포획하였을 경우 함수가 끝난 뒤에도 읽거나 쓸 수 있기 때문에 생명 주기가 달라질 수 있다.
람다가 변경 가능한 변수(var)를 포획할 경우 Ref 객체에 담아 해당 참조를 final로 만들어 사용하도록 한다. Ref 객체 내부의 값은 바뀌어도 되기 때문에 코틀린에서 제공하는 람다에서는 메서드 로컬 변수를 바꾸는 것 처럼 동작한다.
만약 람다가 비동기적으로 동작하여 함수 호출이 끝난 후에 로컬 변수가 변경된다면 클래스/전역 프로퍼티로 두어 변수의 변화를 추적할 수 있도록 해야한다.
아래와 같이 작성할 경우 버튼을 클릭했을 때 람다식이 실행된다. 하지만 함수가 반환된 후에 버튼을 클릭하면 클릭수를 반영할 수 없다.

fun tryToCountButtonClicks(button: Button) : Int {
    var clicks = 0
    button.onClick { clicks++ }
    return clicks
}

만약 람다 자신을 가리키는 것이 필요하다면 이는 불가능하기 때문에 익명 객체를 사용해야 한다.

멤버 참조

클래스에 이미 정의된 함수를 전달하려면 멤버 참조를 이용할 수 있다.
아래와 같이 클래스 이름과 참조하려는 프로퍼티 혹은 메서드 이름 사이에 :: 를 입력하면 멤버 참조가 된다.

Person::age

확장 함수도 멤버 함수와 같은 방식으로 참조 가능하다.

fun Person.isAdult() = age >= 21
val predicate = Person::isAdult

최상위에 선언된 함수나 프로퍼티는 아래와 같이 참조할 수 있다.

fun greetings() = println("안녕하세요.")

fun main(args:Array<String>) {
    run(::greetings)
}

함수의 인자가 많을 경우 람다를 전달하는 것보다 위임 함수에 대한 참조를 제공하는 것이 하나하나 인자를 전달할 필요 없으므로 간편하다.
생성자 참조를 이용해 클래스 생성 작업을 저장할 수 있다. ::클래스이름 형태로 선언할 수 있다.

val createPerson = ::Person
val person = createPerson("Alice", 21)

컬렉션의 함수형 API

filter

컬렉션에서 조건을 만족하는 원소만을 남기기 위한 함수이다.
아래는 사람의 정보를 담은 리스트에서 나이가 30을 초과하는 경우만 리스트로 반환하는 예제이다.

val people = listOf(Person("Alice", 29), Person("Bob", 31))
println(people.filter { it.age > 30 })

map

컬렉션의 모든 원소를 특정 형태로 변형시키기 위한 함수이다.
아래는 사람의 정보를 담은 리스트를 사람의 이름만을 담는 리스트로 반환하는 예제이다.

val people = listOf(Person("Alice", 29), Person("Bob", 31))
people.map( {it.name} )

Map 타입일 경우 key-value 형태이기 때문에 각각 적용하기 위한 filterKeys, mapKeys, filterValues, mapValues 함수가 존재한다.

all, any

컬렉션의 모든 원소가 조건을 만족하거나 일부 원소가 조건을 만족하는지 확인하기 위한 함수이다.

val predicate = { p: Person -> p.age <=20 }
val people = listOf(Person("Alice", 19), Person("Bob", 31))

println(people.all(predicate)) // false
println(people.any(predicate)) // true

count

조건을 만족하는 원소의 개수를 반환하는 함수이다.
filter 함수를 통해 만들어진 컬렉션의 크기를 구하는 것보다, count 함수를 사용하는 것이 효율적이다.

val predicate = { p: Person -> p.age <=20 }
val people = listOf(Person("Alice", 19), Person("Bob", 31))

println(people.count(predicate)) // 1

find

조건을 만족하는 첫 번째 원소를 반환하는 함수이다. 조건을 만족하는 원소가 없으면 null을 반환한다.

val predicate = { p: Person -> p.age <=20 }
val people = listOf(Person("Alice", 19), Person("Bob", 31))

println(people.find(predicate)) // Person(name=Alice, age=19)

groupBy

원소의 특정 속성에 따라 구분하여 Map 형태로 반환하는 함수이다.
아래는 Person 리스트를 나이 기준으로 분류하여 Map<Int, List<Person>> 타입으로 반환하는 예제이다.

val people = listOf(Person("Alice", 19), Person("Bob", 31), Person("Noah", 19))
println(people.groupBy { it.Age })

flatMap, flatten

flatMap 함수는 인자로 주어진 람다를 컬렉션의 모든 원소에 적용한 결과 생성되는 리스트들을 하나로 모은다.
아래는 toList 함수를 사용해 문자열에 속한 문자를 리스트로 만들어버린 후, flatMap으로 리스트들을 하나로 합치는 예제이다.

val strings = listOf("abc", "d", "ef")
val newMap = strings.flatMap { it.toList() } // [a, b, c, d, e, f]

리스트 안에 리스트들이 존재하는 중첩 리스트를 하나의 리스트로 모아야 하고 변환 과정은 필요 없을 땐 flatten 함수를 사용하면 된다.

val listOfLists = listOf(listOf("candy", "jelly"), listOf("noodle", "rice"))
val list = listOfLists.flatten()

지연 계산 연산

앞서 살펴본 컬렉션의 함수형 API는 즉시 결과 컬렉션을 생성해 반환한다. 따라서 컬렉션 함수를 체이닝하면 매 단계마다 중간 컬렉션을 만들게 된다.
시퀀스를 이용하면 자바의 stream과 유사하게 지연 계산 방식으로 동작한다. 즉, map, filter 함수를 체이닝하더라도 원본 컬렉션에 일괄적으로 map, filter 함수를 적용하는 것이 아니라 원소 하나씩 함수를 적용한다.
지연 계산 연산을 통해 즉시 연산에 비해 성능을 향상시킬 수 있다. 예를 들어 map 함수와 find 함수를 체이닝했다면 즉시 연산 시에는 모든 원소에 map 함수를 적용하여 컬렉션을 만들고 해당 컬렉션을 find 함수에 입력할 것이다. 반면 지연 연산 시에는 첫 번째 원소를 map함수, find 함수에 적용해보고 조건이 맞다면 다음 원소는 접근하지 않는다.
시퀀스에 대한 연산은 다른 시퀀스를 반환하는 중간 연산과 결과를 반환하는 최종 연산으로 나뉜다.
asSequence 메서드를 통해 컬렉션 등을 시퀀스로 변환할 수 있다.
시퀀스를 다시 컬렉션으로 만들려면 toXXX 함수를 사용해야 한다.

listOf(1, 2, 3, 4).asSequence()
    .map { print("map($it) "); it * it }
    .filter { print("filter($it) "); it % 2 == 0 }
    .toList()

generateSequence 메서드를 통해 시퀀스 객체를 만들 수 있다.

val naturalNumbers = generateSequence(0) { it + 1 }
val numbersTo100 = naturalNumbers.takeWhile { it <= 100 }
val result = numbersTo100.sum() // 5050

자바의 함수형 인터페이스 활용

추상 메서드가 하나만 있는 인터페이스를 함수형 인터페이스 혹은 SAM(Single Abstract Method) 인터페이스라고 부른다.
코틀린에서 인자가 함수형 인터페이스인 자바 메서드를 호출 시 람다를 넘길 수 있게 해준다.
익명 객체를 넘기게 되면 함수를 호출할 때 마다 새로운 객체가 생성되지만, 람다를 넘기면 반복해서 재사용할 수 있다. 단, 람다가 주변 영역의 변수를 포획한다면 컴파일러는 매번 새로운 객체를 생성해준다.
아래는 익명 객체를 넘기는 것과 람다를 넘기는 것의 예제이다.

postponComputation(1000, object : Runnable {
    override fun run() {
        println(42)
    }
})

postponComputation(1000) { println(42) }

SAM 생성자

SAM 생성자는 람다를 함수형 인터페이스 객체로 변환할 수 있게 컴파일러가 자동 생성한 함수이다.
함수형 인터페이스 타입을 반환하는 메서드의 경우 람다를 직접 반환하는 것은 불가능하며, 람다를 SAM 생성자로 감싸야 한다.
혹은 람다로 생성한 함수형 인터페이스 객체를 변수에 저장하려는 경우도 SAM 생성자를 사용할 수 있다.
SAM 생성자의 이름은 함수형 인터페이스의 타입과 같다.

fun createAllDoneRunnable(): Runnable {
    return Runnable { println("All done!") } // SAM 생성자 사용해 Runnable 타입 객체 생성
}

오버로드한 메서드 중 어떤 타입의 메서드로 람다를 변환해 넘겨줘야 할 지 모호한 경우 명시적으로 SAM 생성자를 적용해 컴파일 오류를 피할 수 있다.

수신 객체 지정 람다

수신 객체를 명시하지 않고 람다 본문 안에서 다른 객체의 메서드를 호출할 수 있도록 하는 것을 의미한다.

with

하나의 객체를 여러번 사용하는 경우 계속해서 변수명을 반복해 작성해주어야 한다.
with 함수를 이용하면 첫 번째 인자로 받은 객체를 두 번째 인자로 받은 람다의 수신 객체로 만들어 람다 본문에서 this로 객체에 접근할 수 있도록 해준다.
with 함수는 람다 코드를 실행한 결과를 반환한다. 따라서 람다의 가장 마지막 식의 값이 반환될 것이다.
아래는 stringBuilder를 첫 번째 인자로 받고, 람다를 두 번째 인자로 받아 문자열을 만들어내는 예제이다.

fun alphabet(): String {
    val stringBuilder = StringBuilder()
    return with(stringBuilder) {
        for (letter in 'A'..'Z') {
            this.append(letter)
        }
        append("\\nNow I know the alphabet!")
        toString()
    }
}

with 함수를 사용하는 클래스와 with에게 인자로 넘긴 객체의 클래스에 동일한 이름을 가진 메서드들이 존재한다면 this 참조 뒤에 레이블을 붙여야 한다.

this@OuterClass.toString()

apply

with와 거의 유사하지만 자신에게 전달된 수신 객체를 그대로 반환한다.
apply는 확장 함수로 정의되어 있다.

fun alphabet() = StringBuilder().apply {
    for (letter in 'A'..'Z') {
        append(letter)
    }
    append("\\nNow I know the alphabet!")
}.toString()

객체를 생성하는 즉시 프로퍼티 중 일부를 초기화해야 하는 경우 apply 함수에 넘겨 프로퍼티를 설정하거나 메서드를 호출할 수 있다.

fun createViewWithCustomAttributes(context: Context) =
    TextView(context).apply {
        text = "sample"
        textSize = 20.0
        setPadding(10, 0, 0, 0)
    }

buildString의 경우 수신 객체가 항상 StringBuilder가 되며 수신 객체 지정 람다를 입력받는다.

fun alphabet() = buildString {
    for (letter in 'A'..'Z') {
        append(letter)
    }
    append("\\nNow I know the alphabet!")
}

Previous클래스, 객체, 인터페이스 Next타입 시스템

Last updated 1 year ago