TIL - Java 기초: 람다 표현식(Lambda Expression) 시작하기

won2dev2025년 03월 20일

💬 배운 기술 / 지식

익명 클래스(Anonymous Class)
함수형 인터페이스(Functional Interface)
메서드 오버로딩(Method Overloading)과 람다식 관계
람다 표현식(Lambda Expression) 문법과 특징
람다식을 사용하는 이유와 장점

1️⃣ 익명 클래스(Anonymous Class)

이름 없는 클래스를 즉석에서 정의하고 객체 생성하는 문법
간단한 인터페이스 구현이나 상속 시 코드 줄이기 위해 사용
기존에는 함수형 인터페이스를 구현할 때 많이 쓰임

예제

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("익명 클래스로 실행");
    }
};
r.run();

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("익명 클래스로 실행");
    }
};
r.run();

2️⃣ 함수형 인터페이스(Functional Interface)

단 하나의 추상 메서드만 갖는 인터페이스
람다 표현식을 사용할 수 있는 대상
@FunctionalInterface 애노테이션으로 명시 가능(컴파일러가 체크)

대표 함수형 인터페이스

이름	기능	메서드 시그니처
`Runnable`	매개변수 없고 반환값 없는 실행	`void run()`
`Supplier<T>`	반환값만 제공하는 함수	`T get()`
`Consumer<T>`	매개변수 하나 받아 처리, 반환없음	`void accept(T t)`
`Function<T,R>`	매개변수 하나 받고 결과 반환	`R apply(T t)`
`Predicate<T>`	매개변수 하나 받고 boolean 반환	`boolean test(T t)`

3️⃣ 메서드 오버로딩과 람다식

람다식은 함수형 인터페이스를 구현하는 익명 객체로 변환됨
메서드 오버로딩이 있을 때 람다식만 보고 어떤 함수형 인터페이스를 사용하는지 컴파일러가 판단해야 함
오버로딩된 메서드 중에 어떤 함수형 인터페이스인지 명확히 해줘야 에러 방지

4️⃣ 람다 표현식(Lambda Expression) 소개

익명 클래스의 복잡한 문법을 줄이고 간결하게 함수(메서드) 구현 가능
파라미터 -> 표현식 형태
함수형 인터페이스 구현체 생성 시 주로 사용
내부적으로 익명 클래스 객체를 생성하지만 문법은 더 간단

람다 문법 기본 형태

형태	설명	예시
`(매개변수) -> 실행문`	매개변수 하나 이상, 실행문 한 줄	`(x) -> x * x`
`(매개변수) -> { 실행문들 }`	실행문 여러 줄일 때 중괄호 필요	`(x, y) -> { return x + y; }`
`() -> 실행문`	매개변수 없는 경우	`() -> System.out.println("Hi")`

5️⃣ 익명 클래스 vs 람다식 비교

// 익명 클래스
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("익명 클래스 실행");
    }
};

// 람다식
Runnable r2 = () -> System.out.println("람다식 실행");

r1.run();
r2.run();

// 익명 클래스
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("익명 클래스 실행");
    }
};

// 람다식
Runnable r2 = () -> System.out.println("람다식 실행");

r1.run();
r2.run();

람다식이 훨씬 간결
익명 클래스는 this가 익명 클래스 자체를 가리키지만, 람다식은 람다를 포함하는 외부 객체를 가리킴(상황에 따라 중요)

6️⃣ 람다식 활용 예제

예제 1: Runnable 인터페이스 구현

public class LambdaExample1 {
    public static void main(String[] args) {
        // 익명 클래스
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("익명 클래스 실행");
            }
        };

        // 람다식
        Runnable r2 = () -> System.out.println("람다식 실행");

        r1.run();
        r2.run();
    }
}

public class LambdaExample1 {
    public static void main(String[] args) {
        // 익명 클래스
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("익명 클래스 실행");
            }
        };

        // 람다식
        Runnable r2 = () -> System.out.println("람다식 실행");

        r1.run();
        r2.run();
    }
}

예제 2: 함수형 인터페이스 직접 정의 후 사용

@FunctionalInterface
interface Calculator {
    int calc(int a, int b);
}

public class LambdaExample2 {
    public static void main(String[] args) {
        // 덧셈 구현 (람다식)
        Calculator add = (a, b) -> a + b;

        // 곱셈 구현 (익명 클래스)
        Calculator multiply = new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a * b;
            }
        };

        System.out.println("덧셈: " + add.calc(3, 5));        // 8
        System.out.println("곱셈: " + multiply.calc(3, 5));   // 15
    }
}

@FunctionalInterface
interface Calculator {
    int calc(int a, int b);
}

public class LambdaExample2 {
    public static void main(String[] args) {
        // 덧셈 구현 (람다식)
        Calculator add = (a, b) -> a + b;

        // 곱셈 구현 (익명 클래스)
        Calculator multiply = new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a * b;
            }
        };

        System.out.println("덧셈: " + add.calc(3, 5));        // 8
        System.out.println("곱셈: " + multiply.calc(3, 5));   // 15
    }
}

예제 3: 메서드 오버로딩과 람다

public class OverloadingExample {

    // 함수형 인터페이스 정의
    interface Printer {
        void print();
    }

    interface IntPrinter {
        void print(int n);
    }

    // 오버로딩 메서드 2개
    public static void run(Printer p) {
        System.out.println("Printer 호출");
        p.print();
    }

    public static void run(IntPrinter p) {
        System.out.println("IntPrinter 호출");
        p.print(100);
    }

    public static void main(String[] args) {
        // 어떤 run() 호출될지 명확하지 않음 → 컴파일 오류 발생 가능

        // 명확히 하기 위해 캐스팅하거나 람다 변수로 분리 가능
        run((Printer) () -> System.out.println("람다 - Printer"));
        run((IntPrinter) (n) -> System.out.println("람다 - IntPrinter: " + n));
    }
}

public class OverloadingExample {

    // 함수형 인터페이스 정의
    interface Printer {
        void print();
    }

    interface IntPrinter {
        void print(int n);
    }

    // 오버로딩 메서드 2개
    public static void run(Printer p) {
        System.out.println("Printer 호출");
        p.print();
    }

    public static void run(IntPrinter p) {
        System.out.println("IntPrinter 호출");
        p.print(100);
    }

    public static void main(String[] args) {
        // 어떤 run() 호출될지 명확하지 않음 → 컴파일 오류 발생 가능

        // 명확히 하기 위해 캐스팅하거나 람다 변수로 분리 가능
        run((Printer) () -> System.out.println("람다 - Printer"));
        run((IntPrinter) (n) -> System.out.println("람다 - IntPrinter: " + n));
    }
}

💡 느낀 점 / 참고 사항

람다식은 자바의 함수형 프로그래밍 핵심 요소로 간결하고 명확한 코드 작성 가능
함수형 인터페이스가 람다 사용의 기반이며, 직접 만들 수도 있음
익명 클래스보다 코드가 훨씬 짧고 읽기 쉬움
메서드 오버로딩이 있는 경우 어떤 함수형 인터페이스인지 명확히 해줘야 에러 방지 가능
람다식과 메서드 레퍼런스(ClassName::methodName)도 함께 배우면 효과적

// 익명 클래스 Runnable r1 = new Runnable() { @Override public void run() { System.out.println("익명 클래스 실행"); } }; // 람다식 Runnable r2 = () -> System.out.println("람다식 실행"); r1.run(); r2.run();

public class LambdaExample1 { public static void main(String[] args) { // 익명 클래스 Runnable r1 = new Runnable() { @Override public void run() { System.out.println("익명 클래스 실행"); } }; // 람다식 Runnable r2 = () -> System.out.println("람다식 실행"); r1.run(); r2.run(); } }

@FunctionalInterface interface Calculator { int calc(int a, int b); } public class LambdaExample2 { public static void main(String[] args) { // 덧셈 구현 (람다식) Calculator add = (a, b) -> a + b; // 곱셈 구현 (익명 클래스) Calculator multiply = new Calculator() { @Override public int calc(int a, int b) { return a * b; } }; System.out.println("덧셈: " + add.calc(3, 5)); // 8 System.out.println("곱셈: " + multiply.calc(3, 5)); // 15 } }

public class OverloadingExample { // 함수형 인터페이스 정의 interface Printer { void print(); } interface IntPrinter { void print(int n); } // 오버로딩 메서드 2개 public static void run(Printer p) { System.out.println("Printer 호출"); p.print(); } public static void run(IntPrinter p) { System.out.println("IntPrinter 호출"); p.print(100); } public static void main(String[] args) { // 어떤 run() 호출될지 명확하지 않음 → 컴파일 오류 발생 가능 // 명확히 하기 위해 캐스팅하거나 람다 변수로 분리 가능 run((Printer) () -> System.out.println("람다 - Printer")); run((IntPrinter) (n) -> System.out.println("람다 - IntPrinter: " + n)); } }