🎯 람다

📖 람다란?

**람다(Lambda)**는 이름 없는 함수를 간단히 표현하는 방법입니다. 짧고 간결한 코드 작성에 유용합니다.

💡 람다 기본

일반 함수 vs 람다

fun main() {
    // 일반 함수
    fun double(x: Int): Int {
        return x * 2
    }

    // 람다
    val doubleLambda = { x: Int -> x * 2 }

    println(double(5))        // 10
    println(doubleLambda(5))  // 10
}

람다 문법

fun main() {
    // 기본 형태: { 매개변수 -> 본문 }
    val sum = { a: Int, b: Int -> a + b }

    println(sum(3, 5))  // 8
}

타입 추론

fun main() {
    // 타입 명시
    val multiply: (Int, Int) -> Int = { a, b -> a * b }

    // 타입 추론 (매개변수 타입 생략)
    val divide = { a: Int, b: Int -> a / b }

    println(multiply(6, 3))  // 18
    println(divide(10, 2))   // 5
}

🎨 람다 활용

리스트와 함께

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // filter - 조건에 맞는 것만
    val evens = numbers.filter { it % 2 == 0 }
    println(evens)  // [2, 4]

    // map - 각 요소를 변환
    val doubled = numbers.map { it * 2 }
    println(doubled)  // [2, 4, 6, 8, 10]

    // forEach - 각 요소에 작업
    numbers.forEach { println(it) }
}

it 키워드

매개변수가 하나면 it으로 참조 가능!

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // it 사용
    val doubled = numbers.map { it * 2 }

    // 명시적 매개변수 (같은 의미)
    val doubled2 = numbers.map { num -> num * 2 }

    println(doubled)   // [2, 4, 6, 8, 10]
    println(doubled2)  // [2, 4, 6, 8, 10]
}

🔧 다양한 람다

여러 줄 람다

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    val result = numbers.map {
        val squared = it * it
        val doubled = squared * 2
        doubled  // 마지막 값이 반환됨
    }

    println(result)  // [2, 8, 18, 32, 50]
}

람다를 인자로 전달

fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    val sum = calculate(5, 3) { a, b -> a + b }
    println(sum)  // 8

    val product = calculate(5, 3) { a, b -> a * b }
    println(product)  // 15
}

마지막 인자가 람다

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // 마지막 인자가 람다면 괄호 밖으로
    val result = numbers.filter { it > 2 }
    println(result)  // [3, 4, 5]

    // 이렇게도 가능 (덜 관용적)
    val result2 = numbers.filter({ it > 2 })
}

🎯 실전 예제

문자열 처리

fun main() {
    val names = listOf("Alice", "Bob", "Charlie", "David")

    // 길이가 5 이상인 이름
    val longNames = names.filter { it.length >= 5 }
    println(longNames)  // [Alice, Charlie, David]

    // 대문자로 변환
    val upperNames = names.map { it.uppercase() }
    println(upperNames)  // [ALICE, BOB, CHARLIE, DAVID]

    // 첫 글자만
    val firstLetters = names.map { it.first() }
    println(firstLetters)  // [A, B, C, D]
}

숫자 필터링

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    // 짝수만
    val evens = numbers.filter { it % 2 == 0 }
    println("짝수: $evens")  // [2, 4, 6, 8, 10]

    // 3의 배수
    val multiplesOf3 = numbers.filter { it % 3 == 0 }
    println("3의 배수: $multiplesOf3")  // [3, 6, 9]

    // 5보다 큰 수
    val greaterThan5 = numbers.filter { it > 5 }
    println("5보다 큰 수: $greaterThan5")  // [6, 7, 8, 9, 10]
}

합계와 평균

fun main() {
    val numbers = listOf(10, 20, 30, 40, 50)

    // 합계
    val sum = numbers.reduce { acc, num -> acc + num }
    println("합계: $sum")  // 150

    // 곱
    val product = numbers.reduce { acc, num -> acc * num }
    println("곱: $product")  // 12000000

    // 평균
    val average = numbers.average()
    println("평균: $average")  // 30.0
}

조건에 맞는 첫 요소

fun main() {
    val numbers = listOf(1, 3, 5, 8, 10, 12)

    // 첫 번째 짝수
    val firstEven = numbers.first { it % 2 == 0 }
    println(firstEven)  // 8

    // 10보다 큰 첫 번째 수
    val firstOver10 = numbers.first { it > 10 }
    println(firstOver10)  // 12
}

정렬

fun main() {
    val names = listOf("Charlie", "Alice", "Bob", "David")

    // 알파벳 순
    val sorted = names.sorted()
    println(sorted)  // [Alice, Bob, Charlie, David]

    // 길이 순
    val sortedByLength = names.sortedBy { it.length }
    println(sortedByLength)  // [Bob, Alice, David, Charlie]

    // 역순
    val reversed = names.sortedDescending()
    println(reversed)  // [David, Charlie, Bob, Alice]
}

🔍 유용한 함수들

any, all, none

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // any - 하나라도 있으면 true
    println(numbers.any { it > 4 })  // true

    // all - 모두 만족하면 true
    println(numbers.all { it > 0 })  // true

    // none - 하나도 없으면 true
    println(numbers.none { it < 0 })  // true
}

take, drop

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // 앞에서 3개
    println(numbers.take(3))  // [1, 2, 3]

    // 앞에서 3개 제외
    println(numbers.drop(3))  // [4, 5]

    // 조건을 만족하는 동안
    println(numbers.takeWhile { it < 4 })  // [1, 2, 3]
}

🤔 자주 묻는 질문

Q1. 람다와 일반 함수의 차이는?

A: 람다는 간단한 작업에, 일반 함수는 복잡한 작업에!

// 간단 → 람다
val double = { x: Int -> x * 2 }

// 복잡 → 일반 함수
fun complexCalculation(x: Int): Int {
    val step1 = x * 2
    val step2 = step1 + 10
    val step3 = step2 / 2
    return step3
}

Q2. it은 언제 쓰나요?

A: 매개변수가 하나일 때 자동으로 생성!

fun main() {
    val numbers = listOf(1, 2, 3)

    // it 사용 (매개변수 1개)
    numbers.map { it * 2 }

    // 명시적 (같은 의미)
    numbers.map { x -> x * 2 }

    // 여러 매개변수는 it 불가
    val sum = { a: Int, b: Int -> a + b }  // it 사용 불가
}

Q3. 언제 람다를 쓰나요?

A: 짧고 단순한 작업에!

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // ✅ 람다가 적합
    numbers.filter { it % 2 == 0 }
    numbers.map { it * 2 }

    // ❌ 너무 복잡하면 함수로
    fun complexFilter(x: Int): Boolean {
        // 복잡한 조건들...
        return true
    }
    numbers.filter { complexFilter(it) }
}

🎬 마치며

람다로 간결하고 표현력 있는 코드를 작성하세요!

핵심 정리:
✅ { 매개변수 -> 본문 } 형태
✅ it으로 간단히 참조
✅ filter, map, forEach 등과 활용
✅ 마지막 인자면 괄호 밖으로
✅ 짧고 간단한 작업에 사용

다음 단계: 고차 함수에서 함수를 인자로 받는 함수를 알아보세요!