Kotlin - 람다 프로그래밍

람다 기본 문법

val peoples = listOf(Person("alice", 29), Person("bob", 31))
println(peoples.maxBy { it.age }) // Persion(name=bob, age=31)

peoples.maxBy(persion::age)

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

 

run : 인자로 받은 람다를 실행해주는 라이브러리 함수

run { println(42) }

peoples.maxBy({ p: Person -> p.age })
peoples.maxBy() { p: Person -> p.age })

 

 

인자에 람다 넘기기

peoples.joinToString(seperator = " ", transform = { p: Person -> p.name })

peoples.joinToString(" ") { p: Person -> p.name }

peoples.maxBy { p: Person -> p.age }
peoples.maxBy { p -> p.age }

 

it : 디폴트 파라미터 이름

peoples.maxBy { it.age }

 

람다를 변수에 저장할 때는 파라미터 타입 추론이 불가하여 반드시 명시

val getAge = { p: Person -> p.age }

 

여러 줄로 이뤄진 람다는 마지막 식이 람다의 결과 값

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

 

현재 영역에 있는 변수에 접근

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

 

람다 안에서 바깥 함수의 로컬 변수 변경하기

fun printProblemCounts(responses: Collection<String>) {
    var clientErrors = 0
    var serverErrors = 0
    responses.forEach {
        if (it.startsWith("4")) {
             clientErrors++
        } else if (it.startsWith("5")) {
             serverErrors++
        }
    }
    println("$clientErros client errors, $serverErrors server errors")
}

 

멤버 참조, 함수 참조

멤버 참조
val getAge = Person::age

최상위 함수 참조
fun salute() = println("salute")
run(::salute)

val nextAction = ::sendEmail

val createPerson = ::Person
val p = createPerson("alice", 29)

확장 함수도 참조 가능
fun Person.isAdult() = age >= 21
val predicate = Person::isAdult

 

컬렉션 함수형 API

- filter
- map
- 맵의 경우 filterKeys, mapKeys, filterValues, mapValues 함수 존재
- all
- any
- count
- find

val isAdult = { p: Person -> p.age >= 21 }

peoples.all(isAdult) // 모두 만족
peoples.any(isAdult) // 하나라도 만족
peoples.count(isAdult) // 만족하는 갯수
peoples.find(isAdult) // 만족하는 원소 한개 찾기, 없는 경우 null

- groupBy : 컬렉션을 맵으로 변환
- flatMap : 중첩된 컬렉션 안의 원소 처리

books.flatMap { it.authors }.toSet()
val strs = listOf("abc", "def")
str.flatmap { it.toList() } >> a, b, c, d, e, f

 

지연 컬렉션 연산

- 시퀀스 연산 실행 : 중간 연산과 최종 연산

sequence.map { }.filter { }.toList()
- 중간 연산 : map, filter
- 최종 연산 : toList

- 자바 8 이후 스트림 = 시퀀스는 동일 / 이전 자바 버전 사용할 경우 시퀀스 사용

 

시퀀스 생성

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

fun File.isInsideHiddenDirectory() = generateSequence(this) { it.parentFile }.any { it.ishidden }
val file = File("/Users/user/.HiddenDir/a.txt")
file.isInsideHiddenDirectory()

자바 메소드에 람다를 인자로 전달
void postponeComputation(int delay, Runnable computation);
postponecomputation(1000) { println(42) }

 

SAM 생성자 : 람다를 함수형 인터페이스로 명시적으로 변경

fun createAllDonerunnable() : Runnable {
    return Runnable { println("done") }
}

>>> createAllDoneRunnable().run()

val listener = OnClickListener { view ->
    val text = when (view.id) {
        R.id.button1 -> "first"
        R.id.button2 -> "second"
        else -> "unknown"
    }
    toast(text)
}
button1.setOnClickListener(listener)
button2.setOnClickListener(listener)

 

수신 객체 지정 람다 : with, apply

with

fun alphabet() : String {
    val result = StringBuilder()
    for (letter in 'A'..'Z') {
        result.append(letter)
    }
    result.append("\nDone")
    return result.toString()
}

// with 사용
fun alphabet() : String {
    val stringBuilder = StringBuilder()
    return with(stringBuilder) {
        for (letter in 'A'..'Z') {
            this.append(letter)
        }
        this.append("\nDone")
        this.toString()
    }
}

// with 사용
fun alphabet() = with(StringBuilder()) {
    for (letter in 'A'..'Z') {
        this.append(letter)
    }
    this.append("\nDone")
    this.toString()
}

apply

fun alphabet() = StringBuilder().apply {
    for (letter in 'A'..'Z') {
        append(letter)
    }
    append("\nDone")
}.toString()