[JAVA] 42. 람다식(Lambda Expressions)

람다식(Lambda Expressions)

- 자바 8에 추가된 가장 큰 특징

- "함수형" 프로그래밍 형태를 받아들인 결과

 

함수형 프로그램이란? (함수형 vs 객체지향)

- 함수형 : 1950년대 , 객체지향 : 1990년대 (역사가 더 오래되었음)

- 기능 위주의 프로그래밍 기법

- 매개변수만을 사용하여 만드는 함수(순수 함수, pure function) 를 구현하고 호출함으로써 외부 자료에 부수적인 영향을 주지 않도록 구현하는 방식

- 객체 지향 : 객체를 기반으로 구현, 클래스에 속성과 기능을 정의

함수형 : 함수를 기반으로 자료를 입력받아 구현, 기능 즉 함수가 따로 존재

 

- 함수 이름이 없는 익명 함수를 만드는 것 메서드의 이름과 리턴타입을 빼고 '->' 를 활용하여 람다식을 구현
ex) public int add(int x, int y) {
return x + y;
}
의 메서드를 람다식으로 표현하면
(int x, int y) -> { return x + y; }

 

< 람다식의 기본 문법 >

(데이터타입 매개변수, ...) -> { 실행문, ... }

 

1. 기본형

(int x) -> { System.out.println(x); }

 

2. 매개변수의 타입을 추론할 수 있는 경우에는 타입 생략 가능

(x) -> { System.out.println(x); }

 

3. 매개변수나 실행문이 하나라면 소괄호() 와 중괄호 {} 를 생략할 수 있음.

(이 때, 세미콜론(;)은 생략!)

x -> System.out.println(x)

주의! 매개변수가 두 개 이상인 경우 소괄호() 를 생략할 수 없다!

 

4. 매개변수가 없을 경우 소괄호() 를 사용한다. (생략 불가!)

() -> System.out.println(x)

 

5. 리턴이 필요한 경우 return 키워드를 사용

(x, y) -> { return x + y; }

주의! return 문은 중괄호를 생략할 수 없다!

 

6. 실행문이 단순히 return 문 하나로 표현되는 경우

표현식만 사용할 수 있으며, 이 때 리턴 값은 표현식의 결과값이 됨

(주의! 이 때, 세미콜론을 붙이지 않는다!)

(x, y) -> x + y

 

// 두 수를 입력받아 큰 수를 출력하는 메서드를 가진 클래스 정의
class MaxPrintNumber {
	public int maxNum(int num1, int num2) {
		if(num1 >= num2) {
			return num1;
		} else {
			return num2;
		}
	}
}

 

 

// MyNumber 인터페이스를 구현한 MyNumberClass 정의
//interface MyNumber {
//	int getMax(int num1, int num2); // 추상 메서드 선언
//}

class MyNumberClass implements MyNumber {
	
	// 두 수를 입력받아 둘 중 큰 숫자를 리턴하는 getMax() 메서드 정의
	@Override
	public int getMax(int num1, int num2) {
		if(num1 >= num2) {
			return num1;
		} else {
			return num2;
		}
	}
}

 

 

위의 getMax() 메서드를 람다식으로 표현하기 위해 함수형 인터페이스 선언한다

=> 자바에서는 참조 변수 없이 메서드를 호출할 수 없음

=> 람다식을 구현하기 위해 함수형 인터페이스를 만들고, 인터페이스에 람다식으로 구현할 메서드를 선언하는 형태로 사용

=> 주의! 람다식은 하나의 메서드를 구현하여 인터페이스형 변수에 대입하므로 인터페이스가 두 개 이상의 메서드를 가지면 안된다!

 

@FunctionalInterface // 함수형 인터페이스 용도로 사용됨을 알림
interface MyNumber {
	int getMax(int num1, int num2); // 추상 메서드 선언
//	int add(int num1, int num2);
}

 

// MaxPrintNumber 클래스 활용
		MaxPrintNumber mpn = new MaxPrintNumber();
		System.out.println(mpn.maxNum(10, 20));
		
		System.out.println("----------------------------");
		
		// 구현클래스를 활용한 getMax 메서드 호출
		MyNumber max = new MyNumberClass(); // 업캐스트 적용
		System.out.println(max.getMax(10, 20));
		
		System.out.println("-----------------------------");
		
		// 람다식 구현과 호출
		MyNumber max2 = (x, y) -> (x >= y) ? x : y ;
		// => 람다식을 인터페이스형 max2 변수에 대입
		System.out.println(max2.getMax(10, 20)); // 인터페이스형 변수로 메서드 호출

 

 

 

 

 

익명 객체를 생성하는 람다식

- 자바는 객체 지향 언어로 객체 없이 메서드를 호출할 수 없다

- 람다식은 객체 없이 인터페이스의 구현만으로 메서드를 호출할 수 있는데 그 이유는 익명 내부 클래스에 있다

- 익명 내부 클래스는 클래스 이름 없이 인터페이스 자료형 변수에 바로 메서드 구현부를 생성하여 대입할 수 있음

- 즉, 람다식으로 메서드를 구현해서 호출하면 컴퓨터 내부에서는 익명클래스가 생성되고, 이를 통해 익명 객체가 생성되는 것

 

 

 

람다식에서 사용하는 지역 변수

- 람다식 코드에서는 외부 메서드의 지역 변수를 수정할 수 없음 그 이유는 지역 변수는 메서드 호출이 끝나면 메모리에서 사라지기 때문에 익명 내부 클래스에서 사용하는 경우에는 지역 변수가 상수로 변하기 때문

 

		int i = 100; // main() 메서드의 지역변수
		
		StringConcat concat2 = (s, v) -> {
//			i = 200; // main() 메서드의 지역변수 i는 상수(final) 이므로 값 변경 불가!
			// => Local variable i defined in an enclosing scope 
			//    must be final or effectively final
			System.out.println(i);
			System.out.println(s + "," + v);
		};
		
		concat2.makeString("itwill", "busan");

		StringConcat concat3 = new StringConcat() {	
			@Override
			public void makeString(String s1, String s2) {
				System.out.println(s1 + "," + s2);
			}
		};
		// => 내부적으로 익명 구현 객체가 생성되어 메서드를 호출할 수 있게 됨
		
		concat3.makeString("Hello", "World");

 

 

 

 

 

 

함수형 인터페이스(functional interface) 또는 타겟타입(target type)

- 람다식은 결과적으로 "인터페이스의 클래스를 손쉽게 구현하는 방법"

- 반드시 하나의 abstract 메서드만 존재

- 만약 abstract 메서드가 없거나 두 개 이상 존재한다면 람다식으로 대체할 수 없음

- 함수형 인터페이스 @FunctionalInterface 어노테이션 선언

 

// 함수형 인터페이스를 사용하는 람다식 유형
// 1. 파라미터와 리턴타입이 없는 경우 (파라미터 : X, 리턴타입 : X)
@FunctionalInterface
interface MyFunc1 {
	// 함수형 인터페이스 어노테이션(@FunctionalInterface) 선언 시 발생!
	// => 함수형 인터페이스는 반드시 하나의 추상메서드(abstract method)를 가져야 함
	public void methodA();
//	public void methodB();
}

// 2. 파라미터가 있는 람다식(파라미터 : O)
@FunctionalInterface
interface MyFunc2 {
	public void methodB(String msg);
}

// 3. 리턴타입이 있는 람다식(파라미터 : O, 리턴타입 : O)
@FunctionalInterface
interface MyFunc3 {
	public String methodC(String msg);
}

 

	// 1. 파라미터와 리턴타입이 없는 경우 (파라미터 : X, 리턴타입 : X)
	public static void useFIMethodA(MyFunc1 fi) {
		fi.methodA();
	}
	
	// 2. 파라미터가 있는 람다식(파라미터 : O)
	public static void useFIMethodB(MyFunc2 fi) {
		fi.methodB("홍길동");
	}
	
	// 3. 리턴타입이 있는 람다식(파라미터 : O, 리턴타입 : O)
	public static String useFIMethodC(MyFunc3 fi) {
		return fi.methodC("이순신");
	}

 

		useFIMethodA(new MyFunc1() {
			@Override
			public void methodA() {
				System.out.println("익명 내부 클래스 형태!");
			}
		});
		
		System.out.println("------------------------------------");
		
		// 1. 파라미터와 리턴타입이 없는 경우 (파라미터 : X, 리턴타입 : X)
		System.out.println("(파라미터 : X, 리턴타입 : X)");
		// 정적 메서드 useFIMethodA의 파라미터가 MyFunc1 의 인터페이스 타입이므로
		// 람다식으로 만들어지는 익명 객체가 파라미터로 사용됨
		
		// 표현방식1
		useFIMethodA( () -> { 
			System.out.println("람다식1!");
		});
		
		// 표현방식2
		useFIMethodA(() -> System.out.println("람다식2!"));
		
		System.out.println("---------------------------------");
		
		// 2. 파라미터가 있는 람다식(파라미터 : O)
		System.out.println("(파라미터 : O, 리턴타입 : X)");
		
		// 표현방식1
		useFIMethodB((String msg) -> {
				System.out.println("람다식1 : " + msg);
			}
		);
		
		// 표현방식2
		useFIMethodB( msg -> System.out.println("람다식2 : " + msg) );
		
		System.out.println("-------------------------------------");
		
		// 3. 리턴타입이 있는 람다식(파라미터 : O, 리턴타입 : O)
		System.out.println("(파라미터 : O, 리턴타입 : O)");
		
		// 표현방식1
		String result = useFIMethodC((String msg) -> {
							return "람다식1 : " + msg;
						});
		System.out.println(result);
		
		// 표현방식2
		System.out.println( useFIMethodC(msg -> "람다식2 : " + msg) );
		

	} // main() 메서드 끝

 

 

 

 

TEST

public class Test {

	public static void main(String[] args) {
		/*
		 * 문자열을 입력받아 두 문자열을 연결하여 출력하는 프로그램 정의
		 * 람다식을 사용하여 구현
		 * ex) Hello 와 World 를 매개변수값으로 전달하면
		 *     "Hello,World" 가 출력
		 */
//	String s1 = "Hello";
//	String s2 = "World";
	Scanner scan = new Scanner(System.in);
	System.out.print("첫 번째 문자열을 입력하세요 : ");
	String s1 = scan.nextLine();
	
	System.out.print("두 번째 문자열을 입력하세요 : ");
	String s2 = scan.nextLine();
	
	// 객체 지향 프로그래밍 방식
	StringConcatImpl sc = new StringConcatImpl();
	sc.makeString(s1, s2);
	
	// ---------------------------------------------
	// makeString() 메서드를 람다식으로 표현
	StringConcat concat = (String s, String v) -> System.out.println(s + ", " + v);
	concat.makeString(s1, s2);
		
	}

}

@FunctionalInterface
interface StringConcat {
	public void makeString(String s1, String s2);
}

class StringConcatImpl implements StringConcat {
	
	@Override
	public void makeString(String s1, String s2) {
		System.out.println(s1 + ", " + s2);
	}
	
}