Kotlin

[RulLu16]

코틀린인액션 5-5/4/5 정리

[RulLu16]

5.3 lazy 계산

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

• 컬렉션 함수를 연쇄하면 매 단계마다 계산 중간결과를 새로운 컬렉션에 임시로 담게된다.
• 즉, 맵 연산을 완료한 결과를 임시 컬렉션에 담고, 해당 컬렉션으로 다시 필터 연산을 하게된다.
• => 원소가 매우 많아져 임시로 담야아할것이 많아지면 효율이 떨어짐!

5.3.1 시퀀스 연산 (java stream과 같은 개념)

• 임시 컬렉션을 생성하지 않고 연산을 연쇄적으로 적용할 수 있는 방법!
• 필요시 계산된다.

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

결과 비교!

noSequence: 
map(1)map(2)map(3)map(4)filter(1)filter(4)filter(9)filter(16)

doSequence: 
map(1)filter(1)map(2)filter(4)map(3)filter(9)map(4)filter(16)

• 중간연산은 시퀀스를 반환하는 연산, 최종연산은 결과를 반환하는 연산.
• 시퀀스는 최종연산이 호출될 때 비로소 연산이 이루어진다!
• 만약 위의 예제에서 최종연산에 해당하는 toList()가 없다면, 연산은 이루어지지 않는다.

모든 연산은 각 원소에 대해 순차적으로 처리되기 때문에, 연산의 순서가 중요해질수도 있다!

println("map > filter")
    val mapfilter = people.asSequence()
          .map{ print("map "); it.name }
          .filter { print("filter "); it.length < 4 }.toList()

println("filter > map")
    val filtermap = people.asSequence()
          .filter { print("filter "); it.name.length < 4 }
          .map{ print("map "); it.name }.toList()

// 결과
map > filter
map filter map filter map filter 

filter > map
filter filter map filter 

5.3.2 시퀀스 만들기

• generateSequence 함수를 이용하여 시퀀스를 만들 수도 있다!
• generateSequence는 이전의 원소를 인자로 받아 다음 원소를 계산.

// generateSequence 사용
val naturalNumbers = generateSequence(0) {it + 1}
val numberTo100 = naturalNumbers.takeWhile { it <= 100 }
    
// 최종연산
println(numberTo100.sum())

• naturalNumbers, numberTo100은 모두 시퀀스!
• 최종연산 sum()을 실행하기 전까지는 계산되지 않는다.

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

5.4.1 람다를 인자로 전달

• 함수형 인터페이스를 인자로 받는 자바 메서드에 코틀린 람다를 넘겨줄수 있다.

//Java 메소드 
void postponeComputation(int delay, Runnable computation);

// 람다를 인자로 전달
// 컴파일러가 람다를 자동으로 Runnable 인스턴스로 변환
// 호출시마다 동일한 객체를 사용
postponeComputation(1000) {println(42)}

// 객체 식을 전달
// 호출시마다 다른 객체를 만들어 사용
postponeComputation(1000, object : Runnable {
    override fun run() {
        println(42)
    }
})

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

SAM? = 단일 추상 메서드 (single abstract method)

• SAM 생성자는 람다를 함수형 인터페이스 인스턴스로 변환할수 있게 컴파일러가 자동생성하는 함수.
• 자동으로 람다를 변환하지 못할 때 SAM 생성자를 사용한다!
• SAM 생성자의 이름은 사용하려는 함수형 인터페이스의 이름과 같다.

fun createAllDoneRunnable(): Runnable {
	return Runnable { println("All done!") }
}

>>> createAllDoneRunnable().run()
// All done!

// 확장함수
val listener = OnClickListener { view -> 
    val text = when (view.id) {
        R.id.button1 -> "First button"
        R.id.button2 -> "Second button"
        else -> "Unknown button"
    }
    toast(text)
}

button1.setOnClickListener(listener)
button2.setOnClickListener(listener)

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

• 수신 객체를 명시하지 않고 람다의 본문 안에서 다른 객체 메소드를 호출할 수 있게 해준다

5.5.1 with

fun alphabetWith():String {
    val stringBuilder = StringBuilder()
    return with(stringBuilder) { // 메서드 호출하려는 수신 객체 지정
        for(letter in 'A'..'Z') {
            this.append(letter) // this를 통해 앞에서 지정한 수신객체의 메서드 호출
        }
        append("\nNow I know the alphabet!") // this는 생략 가능
        this.toString() // 람다에서 값 반환!
    }
}

• 인자로 받은 stringBuilder를 람다식의 수신객체로 만들어준다.
• 람다 본문에서는 this를 사용해 그 수신객체에 접근할 수 있다. (this는 생략 가능!)
• 결국 with가 반환해주는 것은, 람다 코드를 실행한 결과!

5.5.2 apply

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

• apply가 반환해주는 것은 람다의 수신 객체. 즉, StringBuilder를 반환하게 된다!
• 인스턴스를 만들면서 즉시 일부를 초기화해야할 때 유용하게 사용할 수 있다.

fun applyInit(name: String, age: Int) = Person(name, age).apply {
    this.name = name
    this.age = 23
}