람다 본격적으로 알아보기

람다(Lambda)란?

• 자바 8부터 도입된 익명 함수
• 익명 클래스보다 간결한 문법
• 기본 문법:

(매개변수) -> { 본문 }

예시

// 익명 클래스
Procedure procedure = new Procedure() {
    @Override
    public void run() {
        System.out.println("hello! lambda");
    }
};

// 람다 표현
Procedure procedure = () -> {
    System.out.println("hello! lambda");
};

람다 vs 람다식

용어	설명
람다	익명 함수를 지칭하는 개념
람다식	자바에서 람다를 구현한 문법 표현

함수형 인터페이스

@FunctionalInterface
public interface MyFunction {
    int apply(int a, int b);
}

• @FunctionalInterface로 함수형 인터페이스 보장
• 추상 메서드가 하나만 있어야 함

람다 문법 정리

문법	예시
기본형	(int a, int b) -> { return a + b; }
중괄호 + return 생략	(a, b) -> a + b
타입 생략	(a, b) -> a + b
매개변수 1개일 때 괄호 생략	x -> x * 2
매개변수 없음	() -> System.out.println("hi")

람다 활용 예시

1. 변수에 저장

MyFunction add = (a, b) -> a + b;
System.out.println(add.apply(3, 5)); // 8

2. 메서드에 전달

public static void calculate(MyFunction function) {
    int result = function.apply(10, 5);
    System.out.println("결과: " + result);
}

calculate((a, b) -> a * b); // 결과: 50

3. 메서드에서 반환

public static MyFunction getOperation(String op) {
    if (op.equals("add")) return (a, b) -> a + b;
    return (a, b) -> a - b;
}

고차 함수 예제 (Higher-Order Function)

filter - 조건에 맞는 요소만 필터링

public static List<Integer> filter(List<Integer> list, MyPredicate p) {
    List<Integer> result = new ArrayList<>();
    for (int val : list) {
        if (p.test(val)) result.add(val);
    }
    return result;
}

List<Integer> numbers = List.of(-3, -2, -1, 0, 1, 2);
List<Integer> negatives = filter(numbers, x -> x < 0);
System.out.println(negatives); // [-3, -2, -1]

map - 각 요소 변환

public static List<String> map(List<String> list, StringFunction func) {
    List<String> result = new ArrayList<>();
    for (String s : list) {
        result.add(func.apply(s));
    }
    return result;
}

List<String> words = List.of("java", "lambda");
List<String> upper = map(words, s -> s.toUpperCase());
System.out.println(upper); // [JAVA, LAMBDA]

reduce - 하나의 값으로 누적

public static int reduce(List<Integer> list, int initial, MyReducer reducer) {
    int result = initial;
    for (int val : list) {
        result = reducer.reduce(result, val);
    }
    return result;
}

List<Integer> nums = List.of(1, 2, 3, 4);
int sum = reduce(nums, 0, (a, b) -> a + b); // 10
int product = reduce(nums, 1, (a, b) -> a * b); // 24

람다 반환 & 함수 합성

함수 반환

public static StringFunction buildGreeter(String greeting) {
    return name -> greeting + ", " + name;
}

StringFunction greeter = buildGreeter("Hello");
System.out.println(greeter.apply("Java")); // Hello, Java

함수 합성 (compose)

public static MyTransformer compose(MyTransformer f1, MyTransformer f2) {
    return s -> f2.transform(f1.transform(s));
}

MyTransformer toUpper = s -> s.toUpperCase();
MyTransformer addStar = s -> "**" + s + "**";

MyTransformer composed = compose(toUpper, addStar);
System.out.println(composed.transform("hello")); // **HELLO**

마무리 정리

항목	설명
람다	자바에서 함수형 프로그래밍을 위한 익명 함수
함수형 인터페이스	단일 추상 메서드를 가진 인터페이스
고차 함수	함수를 인자로 받거나 반환하는 함수
패턴	filter, map, reduce, compose, return 등

스트림, 컬렉션 처리에서도 자주 쓰이는 고차 함수 패턴들
익숙해지면 코드가 한층 깔끔하고 선언적으로 바뀐다.