[고급자바] 람다

1. 람다

 

람다 : 익명함수를 생성하기 위한 식. 자바에서는 '매개변수를 가진 코드 블럭' => 런타임시 익명구현 객체로 생성된다.

형식) 인터페이스명 객체변수명 = 람다식; 람다식의 형식) (매개변수들...) -> { 처리할 코드들; ... }

람다식으로 변환할 수 있는 인터페이스는 추상메소드가 1개인 인터페이스만 처리할 수 있다. 이런 인터페이스를 '함수적 인터페이스'라고 한다. 이 함수적 인터페이스를 만들 때는 @FunctionalInterface로 지정한다.

 

    public static void main(String[] args) {
        
        // 람다식을 사용하지 않는 경우
        Thread th1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                for(int i=1; i<=10; i++) {
                    System.out.println(i);
                }
                
            }
        });
        
        th1.start();
        
        // 람다식을 사용하는 경우
        Thread th2 = new Thread(
            ()->{
                for(int i=1; i<=10; i++) {
                    System.out.println("람다 - " + i);
                }    
            }
        );
        th2.start();
                
    } 

 

2. 람다식 작성 방법

 

람다식 작성 방법 기본형식) (자료형 이름 매개변수명, ...) -> { 실행문들; ... }
1) 매개변수의 '자료형 이름'은 생략할 수 있다.	예) (int a) -> { System.out.println(a);}         (a)    -> { System.out.println(a);}
2) 매개변수가 1개일 경우에는 괄호 '( )'를 생략할 수 있다.	예) a -> { System.out.println(a);}
3) '실행문'이 1개일 경우에는 ' { } '를 생략할 수 있다.     (이때, 문장의 끝을 나타내는 세미콜론(;)도 생략한다.)	예) a -> System.out.println(a);
4) 매개변수가 하나도 없으면 괄호 '( )'를 생략할 수 있다.	예) (  ) -> System.out.println("안녕");
5) 반환값이 있을 경우에는 return 명령을 사용한다.	예) (a, b) -> { return a+b;}       (a, b) -> return a+b
6) 실행문에 return문만 있을 경우 return명령과 '{ }'를 생략할 수 있다.	예) (a, b) -> a + b

 

package kr.or.ddit.basic;
 
public class T02LambdaTest {
    public static void main(String[] args) {
        
        // 람다식을 사용하지 않았을 경우...
        LambdaTestInterface1 lam1 = new LambdaTestInterface1() {
            
            @Override
            public void test() {
                System.out.println("안녕하세요.");
                System.out.println("익명 구현 객체 방식입니다.");
                
            }
        };
        lam1.test();  // 메소드 호출 
        
        // 람다식을 사용했을 때...
        LambdaTestInterface1 lam2 = 
                () -> System.out.println("반갑습니다.\n람다식으로 처리하는 방식입니다.");  // ;생략 못하는 이유?  lam2.test랑 구분하기 위해
        lam2.test();  // 메소드 호출 
        
        
        
        /* Consumer<Integer> lam3 =
                (Integer z) -> {
                    int result = z + 100;
                     System.out.println("result = " + result);
                 };
                 
        lam3.accept(30);*/
        
        LambdaTestInterface2 lam3 = 
                 (int z) -> {
                     int result = z + 100;
                     System.out.println("result = " + result);
                 };
                 
        lam3.test(30);
         
        LambdaTestInterface2 lam4 =
                 z -> {
                     int result = z + 300;
                     System.out.println("result = " + result);
                 };
        lam4.test(60);
         
        LambdaTestInterface2 lam5 = 
                 z -> System.out.println("result = " + (z+50));
        lam5.test(90);
         
        System.out.println("----------------------------------------");
         
        /* BiFunction<Integer, Integer, Integer> lam 6 = 
                (Integer x, Integer y) -> {
                    int r = x + y;
                    return r;
                };*/
                
        LambdaTestInterface3 lam6 = 
                 (int x, int y) -> {
                     int r = x + y;
                     return r;
                 };
        int k = lam6.test(20, 50);
        System.out.println("k = " + k);
        
        LambdaTestInterface3 lam7 =
                (x, y) -> {
                    return x + y;
                };
        k = lam7.test(80, 50);
        System.out.println("k = " + k);
        
        LambdaTestInterface3 lam8 = 
                (x, y) -> x + y;
        k = lam8.test(100, 200);
        System.out.println("k = " + k);
        
        LambdaTestInterface3 lam9 =
                (x, y) -> x > y ? x : y;
        k = lam9.test(100, 200);
        System.out.println("k = " + k);
                
        
    }
 
}

 

**

 

package kr.or.ddit.basic;
 
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
 
public class T03LambdaTest {
    public static void main(String[] args) {
        
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        
        for(Integer i : list) {
            System.out.println();
        }
        System.out.println();
        
        list.forEach(new Consumer<Integer>( ) {
            
            @Override
            public void accept(Integer t) {
                System.out.println(t + 100);
            }
        });
        
        list.forEach(a -> System.out.println(a + 100));
        
        }
 
}