[Java 고급] 15장 람다식

 

람다식 (= 익명 함수)

 

: 익명함수를 생성하기 위한 식

객체를 function 처럼 바꿀 수 있음 => 코드가 간결해짐(가독성이 좋아짐)

 

 

- 사용방법

인터페이스명 객체변수명 = 람다식;

// 람다식 형식)
(자료형이름 매개변수명,...) -> {실행문들;...}

 

=> 람다식으로 변환할 수 있는 인터페이스는 추상메서드가 1개인 인터페이스만 처리할 수 있다.
  이런 인터페이스를 '함수적 인터페이스(Functional Interface)' 라고 한다.

 

 

+ 추상 메소드 :  자식 클래스에서 반드시 오버라이딩해야만 사용할 수 있는 메소드

 

 

package kr.or.ddit.basic;

public class T01LambdaTest {
/*
 * 람다식 => 익명함수를 생성하기 위한식,
 * 			자바에서는 '매개변수를 가진 코드블럭' => 런타임시에 익명구현 객체로 생성된다.
 * 
 * 사용방법) 인터페이스명 객체변수명 = 람다식;
 * 람다식 형식) (매개변수들...) -> {처리할 코드들;...}
 * 
 * => 람다식으로 변환할 수 있는 인터페이스는 추상메서드가 1개인 인터페이스만 처리할 수 있다.
 * 	    이런 인터페이스를 '함수적 인터페이스(Functional Interface)' 라고 한다.
 */
	
	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();
	}
}

 

결과 화면1

 

 

package kr.or.ddit.basic;

// @FunctionalInterface가 붙었기에 추상 메서드가 하나여야 함
@FunctionalInterface
public interface LambdaTestInterface1 {
	// 반환값이 없고 매개변수도 없는 추상 메서드 선언
	public void test();
}

@FunctionalInterface
interface LambdaTestInterface2 {
	// 반환값이 없고 매개변수는 있는 추상 메서드 선언
	public void test(int a);
}

@FunctionalInterface
interface LambdaTestInterface3 {
	// 반환값도 있고 매개변수도 있는 추상메서드 선언
	public int test(int a, int 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();
		System.out.println("------------------------------------------------");
			
	}
}

 

결과 화면2

 

 

 

람다식 작성 규칙

 

1. 매개변수의 '자료형이름' 생략 가능
ex) (int a) -> {System.out.println(a);}
(a) -> {System.out.println(a);}

2. 매개변수 1개 > 괄호'()' 생략 가능
   (단, '자료형이름'을 지정할 경우에는 생략할 수 없다.)
ex) a -> {System.out.println(a);}

3. '실행문' 1개 > 중괄호'{}' 생략 가능
   (이 때 문장의 끝을 나타내는 세미콜론(;)도 생략할 수 있다.)
ex) a -> System.out.println(a)

4. 매개변수 X > 괄호'()' 생략 불가
ex) () -> System.out.println("안녕")

5. 반환값 O > return명령 사용
ex) (a, b) -> { return a + b; }
(a, b) -> return a + b

6. 실행문에 return문만 있음 > return명령과 중괄호'{}'를 생략 가능
ex) (a, b) -> a + b

 

 

package kr.or.ddit.basic;

public class T02LambdaTest {
	public static void main(String[] args) {
		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+500));
		lam5.test(90);
		
		System.out.println("----------------------------------------");
		
		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);
	}
}

 

결과 화면3

 

 

 

• 람다식 변경

사용법	뜻
Consumer<Integer> .accept()	매개변수가 하나일 때
BiFunction<Integer, Integer, Integer> .apply()	매개변수가 세 개일 때

 

package kr.or.ddit.basic;

import java.util.function.Consumer;

public class T02LambdaTest {
	public static void main(String[] args) {
		Consumer<Integer> lam3 = 
			(Integer z) -> {
				int result = z + 100;
				System.out.println("result = " + result);
			};
		lam3.accept(30);
		
		Consumer<Integer> lam4 =
			z -> {
				int result = z + 300;
				System.out.println("result = " + result);
			};
		lam4.accept(60);
				
		Consumer<Integer> lam5 = 
			z -> System.out.println("result = " + (z+500));
		lam5.accept(90);
        
		System.out.println("----------------------------------------");
		
		BiFunction<Integer, Integer, Integer> lam6 = 
			(x, y) -> {
				int r = x + y;
				return r;
			};
		int k = lam6.apply(20, 50);
		System.out.println("k = " + k);
		
		BiFunction<Integer, Integer, Integer> lam7 = 
			(x, y) -> {
				return x + y; 
			};
		k = lam7.apply(80, 50);
		System.out.println("k = " + k);
		
		BiFunction<Integer, Integer, Integer> lam8 = 
			(x, y) -> x + y;
		k = lam8.apply(100, 200);
		System.out.println("k = " + k);
		
		BiFunction<Integer, Integer, Integer> lam9 = 
			(x, y) -> x > y ? x : y;
		k = lam9.apply(100, 200);
		System.out.println("k = " + k);
	}
}

 

결과 화면4 : Consumer과 BiFunction 사용

 

 

package kr.or.ddit.basic;

import java.util.ArrayList;
import java.util.List;

public class T03LambdaTest {
	public static void main(String[] args) {
		List<String> strList = new ArrayList<String>();
		strList.add("홍길동1");
		strList.add("홍길동2");
		strList.add("홍길동3");
		
		for (String str : strList) {
			System.out.println(str);
		}
		System.out.println();
		
		// foreach문 사용하지 않고 출력
		strList.forEach(str->System.out.println(str));
	}
}

 

결과 화면5