100 No

14.1 람다식이란?

2017-09-03 18:46:12 By 머나먼나라 0 977 댓글수 4 포스트 하기

4월 2024
일	월	화	수	목	금	토
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30

14.1 람다식이란?

자바는 객체 지향 프로그래밍이 소프트웨어 개발의 주요 패러다임이었던 1990 년대에 디자인되었다. 객체 지향 프로그래밍이 나오기 오래전부터 Lisp 또는 Scheme 와 같은 함수적 프로그래밍 언어들이 있었는데, 하계를 제외하고 현업에서 큰 호응을 받지 못했다. 최근 들어 함수적 프로그래밍이 다시 부각되어고 있는데, 병렬 처리와 이벤트 지향 프로그래밍에 적합하기 때문이다. 그래서 객체 지향 프로그래밍과 함수적 프로그래밍을 혼합함으로써 더욱 효휼적인 프로그래밍이 될 수 있도록 프로그램 개발 언어가 변하고 있다.

자바는 함수적 프로그래밍을 위해 자바 8부터 람다식 을 지원하면서 기존의 코드 패턴이 많이 달라졌다. 람다식은 수학자 알론조 처지(Alonzo Church) 가 발표한 람다 계산법에서 사용된 식으로 , 이를 제자 존 매카시(John McCarthy)가 프로그래밍 언어에 도입했다.

람다식은 익명 함수(anonymous function) 를 생성하기 위한 식으로 객체 지향 언어보다는 함수 지향 언어에 가깝다. 객체 지향 프로그래밍에 익숙한 객발자들은 다소 혼란스러울 수 있지만, 자바에서 람다식을 수용한 이유는 자바 코드가 매우 간결해지고 , 컬렉션의 요소를 필터링하거나 매핑해서 원하는 결과를 쉽게 집계할 수 있기 때문이다. 람다식의 형태는 매개 변수를 가진 코드 블록이지만, 런타입 시에는 익명 구현 객체를 생성한다.

람다식 -> 매개 변수를 가진 코드 블록 -> 익명 구현 객체

예를 들어 Runnable 인터페이스의 익명 구현 객체를 생성하는 전형적인 코드는 다음과 같다.

Runnable runnable =new Runnable() {

public void run() {....}

};

위 코드에서 익명 구현 객체를 람다식으로 표현하면 다음과 같다.

Runnable runnable = () ->{....}

람다식은 "(매개변수)->{실행 코드}" 형태로 작성되는데, 마치 함수 정의 형태를 띠고 있지만 런타임 시에 인터페이스의 익명 구현 객체로 생성된다.

어떤 인터페이스를 구현할 것인가는 대입되는 인터페이스가 무엇이냐에 달려 있다. 위 코드는 Runnable 변수에 대입되므로 람다식은 Runnable의 익명 구현 객체를 생성하게 된다.

14.2 람다식 기본 문법

함수적 스타일의 람다식을 작성하는 방법은 다음과 같다.

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

(타입 매개변수, ...) 는 오른쪽 중괄호 {} 블록을 실행하기 위해 필요한 값을 제공하는 역할을 한다.

매개 변수의 이름은 개발자가 자유롭게 줄 수 있다. -> 기호는 매개 변수를 이용해서 중괄호 { } 를 실행한다는 뜻으로 해서하면 된다. 예를 들어 int 매개변수 a의 값을 콘솔에 출력하기 위해 다음과 같이 람다식을 작성할 수 있다.

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

매개 변수 타입은 런타임 시에 대입되는 값에 따라 자동으로 인식될 수 있기 때문에 람다식에서는 매개 변수의 타입을 일반적으로 언급하지 않는다.

그래서 위 코드는 다음과 같이 작성할 수 있다.

(a) -> {System.out.print(a); }

하나의 매개 변수만 있다면 괄호 () 를 생략할 수 있고, 하나의 실행문만 있다면 중괄호 {} 도 생략할 수 있다. 그래서 위 코드는 다음과 같이 작성할 수도 있다.

a -> System.out.println(a);

만약 매개 변수가 없다면 람다식에서 매개 변수 자리가 없어지므로 다음과 같이 빈 괄호() 를 반드시 사용해야 한다.

( ) -> { 실행문 ; ....}

중괄호{} 를 실행하고 결과값을 리턴해야 한다면 다음과 같이 return 문으로 결과값을 지정할 수 있다.

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

중괄 호 {} 에 return 문만 있을 경우, 람다식에서는 return 문을 사용하지 않고 다음과 같이 작성하는 것이 정석이다.

(x, y) -> x + y;

14.3.1 함수적 인터페이스(@FunctionalInterface)

모든 인터페이스를 람다식의 타겟 타입으로 사용할 수는 없다. 람다식이 하나의 메소드를 정의하기 때문에 두 개 이상의 추상 메소드가 선언된 인터페이스는 람다식을 이용해서 구현 객체를 생성할 수 없다. 하나의 추상 메소드가 선언된 인터페이스만이 람다식의 타겟 타입이 될 수 있는데, 이러한 인터페이스를 함수적 인터페이스(functional interface) 라고 한다. 함수적 인터페이스를 작성할 때 두 개 이상의 추상 메소드가 선언되지 않도록 컴파일러가 체킹해주는 기능이 있는데, 인터페이스 선언 시 @FunctionalInterface 어노페이션을 붙이면 된다. 이 어노테이션은 두 개 이상의 추상 메소드가 선언되면 컴파일 오류를 발생시킨다.

@FunctionalInterface
public interface MyFunctionalInterface {

   public void method();
   public void otherMethod();// 컴파일 오류

}

@FunctionalInterface 어노테이션은 선택사항이다. 이 어노테이션이 없더라도 하나의 추상 메소드만 있다면 모두 함수적 인터페이스이다. 그러나 실수로 두 개 이상의 추상 메소드를 선언하는 것을 방지하고 싶다면 붙여주는 것이 좋다. 람다식은 타겟 타입인 함수적 인터페이스가 가지고 있는 추상 메소드의 선언 형테에 따라서 작성 방법이 달라지는데, 이것에 대해서 자세히 알아보기로 하자.

14.3.2 매개 변수와 리턴값이 없는 람다식

다음과 같이 매개 변수와 리턴값이 없는 추상 메소드를 가진 함수적 인터페이스가 있다고 가정해 보자.

@FunctionalInterface
public interface MyFunctionalInterface {

public void method();

}

이 인터페이스를 타겟 타입으로 갖는 람다식은 다음과 같은 형태로 작성해야 한다. 람다식에서 매개 변수가 없는 이유는 method() 가 매개 변수를 가지지 않기 때문이다.

MyFunctionalInterface fi = () -> { .....}

람다식이 대입된 인터페이스의 참조 변수는 다음과 같이 method() 를 호출할 수 있다. method() 호출은 람다식의 중괄호 {} 를 실행시킨다.

fi.method();

public class MyFunctionalInterfaceExample {

   public static void main(String[] args) {

       MyFunctionalInterface fi;

       fi =()->{
           String str ="method call1";
           System.out.println(str);
       };

       fi.method();

       fi=()->{
           System.out.println("method call2");
       };
       fi.method();

       fi =()->System.out.println("method call3");
       fi.method();
   }

}

14.3.3 매개 변수가 있는 람다식

다음과 같이 매개 변수가 있고 리턴값이 없는 추상 메소드를 가진 함수적 인터페이스가 있다고 보자.

@FunctionalInterface
public interface MyFunctionalInterface2 {
public void method(int x);
}

이 인터페이스를 타겟 타입으로 갖는 람다식은 다음과 같은 형태로 작성해야 한다. 람다식에서 매개 변수가 한 개인 이유는 method() 가 매개 변수를 하나만 가지기 때문이다.

MyFunctionalInterface2 fi = (x) -> {....} 또는 x -> {....}

람다식이 대입된 인터페이스 참조 변수는 다음과 같이 method() 를 호출할 수 있다. 매개값으로 5를 주면 람다식의 x변수에 5가 대입되고 x는 중괄호 {} 에서 사용된다.

fi.method(5);

public class MyFunctionalInteferfaceExample {

   public static void main(String[] args) {

       MyFunctionalInterface2 fi ;

       fi =(x) ->{
           int result =x *5;
           System.out.println(result);
       };
       fi.method(2);

       fi =(x)->{System.out.println(x*5); };
       fi.method(2);

       fi =x->System.out.println(x*5);
       fi.method(2);

   }

}

14.3.4 리턴값이 있는 람다식

다음과 같이 매개 변수가 있고 리턴값이 있는 추상 메소드를 가진 함수적 인터페이스가 있다고 보자.

@FunctionalInterface
public interface MyFunctionalInteface {

public int method(int x, int y);
}

이 인터페이스를 타겟 타입으로 갖는 람다식은 다음과 같은 형태로 작성해야 한다. 람다식에서 매개 변수가 두 개인 이유는 method() 가 매개 변수를 두 개 가지기 때문이다. 그리고 method() 가 리턴 타입이 있기 때문에 중괄호 {} 에는 return 문이 있어야 한다.

MyFunctionalInterface fi =(x, y) -> { .. ; return 값; }

만약 중괄호 {} 에 return 문만 있고, return 문 뒤에 연산식이나 메소드 호출이 오는 경우라면 다음과 같이 작성할 수 있다.

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

-> MyFunctionalInterface fi =(x, y) -> x + y;

MyFunctionalInterface fi =(x, y) -> { return sum(x, y); }

-> MyFunctionalInterface fi =(x, y) -> sum(x, y);

람다식이 대입된 인터페이스 참조 변수는 다음과 같이 method() 를 호출할 수 있다. 매개값으로 2 와 5를 주면 람다식의 x 변수에 2, y 변수에 5가

대입되고 x 와 y 는 중괄호 {} 에서 사용된다.

int result =fi.method(2, 5);

public class MyFunctionalInterfaceExample {

   public static void main(String[] args) {

       MyFunctionalInteface fi;

       fi=(x, y)->{
           int result =x +y;
           return result;
       };

       System.out.println(fi.method(2, 5));

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

       System.out.println(fi.method(2, 5));

       fi =(x, y) ->x+y;
       System.out.println(fi.method(2, 5));


   }

   public static int sum(int x, int y){
       return (x + y);
   }


}

14.4 클래스 멤버와 로컬 변수 사용

람다식의 실행 블록에는 클래스의 멤법 (필드와 메소드) 및 로컬 변수를 사용할 수 있다. 클래스의 멤버는 제약 사항 없이 사용 가능하지만, 로컬 변수는 제약 사항이 따른다. 자세한 내용을 알아보기로 하자.

14.4.1 클래스의 멤버 사용

람다식 실행 블록에는 클래스의 멤버인 필드와 메소드를 제약 사항 없이 사용할 수 있다. 하지만 this 키워드를 사용할 때에는 주의가 필요하다. 일반적으로 익명 객체 내부에서 this는 익명 객체의 참조이지만, 람다식에서 this는 내부적으로 생성되는 익명 객체의 참조가 아니라 람다식을 실행한 객체의 참조이다. 다음 예제는 람다식에서 바깥 객체와 중첩 객체의 참조를 얻어 필드값을 출력하는 방법을 보여주고 있다. 중첩 객체 Innter에서 람다식을 실행했기 때문에 람다식 내무에서의 this는 중첩 객체 Inner 이다.

public interface MyFunctionalInterface {
public void method();
}

public class UsingThis {

   public int outterField =10;

   class Inner{

       int innerField =20;

       void method(){

           //람다식
           MyFunctionalInterface fi =()->{
               System.out.println("outterField :" + outterField);
               //바깥 객체의 참조를 얻기 위해서는 클래스명 this 를 사용.
               System.out.println("outterField :" + UsingThis.this.outterField + "\n");

               System.out.println("innerField : "+ innerField);
               //람다식 내부에서 this 는 Inner 객체를 참조.
               System.out.println("innerField : " + this.innerField + "\n");

           };
           fi.method();
       }
   }

}

public class UsingThisExample {

   public static void main(String[] args) {

       UsingThis usingThis =new UsingThis();
       UsingThis.Inner inner =usingThis.new Inner();
       inner.method();
   }
}

14.4.2 로컬 변수 사용

람다식은 메소드 내부에서 주로 작성되기 때문에 로컬 익명 구현 객체를 생성시킨다고 봐야 한다.

람다식에서 바깥 클래스의 필드나 메소드는 제한 없이 사용할 수 있으나, 메소드의 매개 변수 또는 로컬 변수를 사용하면 이 두 변수는 final 특성을

가져야 한다. 왜 final 특성을 가져야 되는지 이유를 알 고 싶다면 9.5.3 익명 객체의 로컬 변수 사용을 읽어보길 바란다. 따라서 매개 변수 또는 로컬

변수를 람다식에서 읽는 것은 허용되지만, 람다식 내부 또는 외부에서 병경할 수 없다. 다음 예제 코드를 보면서 이해해 보자.

public class UsingLocalVariable {
   void method(int arg){ //arg은 final 특성을 가짐
       int localVar =40; // localVar 는 final 특성을 가짐

       //arg =31; //final 특성 때문에 수정 불가
       //localVar =41 ; //final 특성 때문에 수정 불가

       //람다식
       MyFunctionalInterface fi =()->{

           //로컬 변수 읽기
           System.out.println("arg : " + arg);
           System.out.println("localVar : " + localVar + "\n");

       };
       fi.method();
   }
}

public class UsingLocalVariableExample {
   public static void main(String[] args) {
       UsingLocalVariable ulv =new UsingLocalVariable();
       ulv.method(20);
   }
}

arg : 20
localVar : 40

14.5 표준 API 의 함수적 인터페이스

자바에서 제공되는 표준 API에서 한 개의 추상 메소드를 가지는 인터페이스들은 모두 람다식을 이용해서 익명 구현 객체로 표현이 가능하다.

예를 들어 스레드의 작업을 정의하는 Runnable 인테페이스는 매개 변수와 리턴값이 없는 run() 메소드만 존재하기 때문에 다음과 같이 람다식을 이

용해서 Runnable 인스턴스를 생성시킬 수 있다.

public class RunnableExample {

   public static void main(String[] args) {
       Runnable runnable = () ->{
           for(int i=0; i<10; i++){
               System.out.println(i);
           }
       }; //람다식 (스레드가 실행하는 코드)

       Thread thread =new Thread(runnable);
       thread.start();
   }

}

0
1
2
3
4
5
6
7
8
9

Thread thread =new Thread(()->{
           for(int i=0; i<10; i++){
               System.out.println(i);
           }
       });

자바 8부터는 번번하게 사용되는 함수적 인터페이스(functional interface) 는 java.util.function 표준 API 패키지로 제공한다. 이 패키지에서 제공하는 함수적 인터페이스의 목적은 메소드 또는 생성자의 매개 타입으로 사용되어 람다식을 대입할 수 있도록 하기 위해서이다. 자바 8부터 추가되거나 변경된 API 에서 이 함수적 인터페이스들을 매개 타입으로 많이 사용한다. 물론 여러분이 개발하는 메소드에도 이 함수적 인터페이스들을 매개 타입으로 사용할 수 있다. java.util.function 패키지의 함수적 인터페이스는 크게 Consumer, Supplier, Function, Operator , Predicate 로 구분된다. 구분 기준은 인터페이스에 선언된 추상 메소드의 매개값과 리턴값의 유무이다.

종류	추상 메소드 특징
Consumer	- 매개값은 있고, 리턴값은 없음	매개값 -> Consumer
Supplier	- 매개값은 없고, 리턴값은 있음	Supplier ->리턴값
Function	- 매개값도 있고, 리턴값도 있음 - 주로 매개값을 리턴값으로 매핑(타입 변환)	매개값 ->Operator->리턴값
Operator	- 매개값도 있고, 리턴값도 있음 - 주로 매개값을 연산하고 결과를 리턴	매개값 -> Operator ->리턴값
Predicate	- 매개값은 있고, 리턴 타입 boolean - 매개값을 조사해서 true/false 를 리턴	매개값 -> Predicate ->boolean

14.5.1 Consumer 함수적 인터페이스

Consumer 함수적 인터페이스의 특징은 리턴값이 없은 accept() 메소드를 가지고 있다. accept() 메소드는 단지 매개값을 소비하는 역할만 한다.

여기서 소비한다는 말은 사용할 뿐 리턴값이 없다는 뜻이다.

매개 변수의 타입과 수에 따라서 아래와 같은 Consumer 들이 있다.

인터페이스명	추상 메소드	설명
Consumer<T>	void accept(T t)	객체 T를 받아 소비
BiConsumer<T, U>	void accept(T t, U u)	객체 T와 U를 받아 소비
DoubleConsumer	void accept(double value)	double 값을 받아 소비
intConsumer	void accept(int value)	int 값을 받아 소비
LongConsumer	void accept(long value)	long 값을 받아 소비
ObjDoubleConsumer<T>	void accept(T t, double value)	객체 T와 double 값을 받아 소비
ObjIntConsumer<T>	void accept(T t, int value)	객체 T와 int 값을 받아 소비
ObjLongConsuer<T>	void accept(T t, long value)	객체 T와 long 값을 받아 소비

Consumer<T> 인터페이스를 타겟 타입으로 하는 람다식은 다음과 같이 작성할 수 있다.

accept() 메소드는 매개값으로 T 객체 하나를 가지므로 람다식도 한 개의 매개 변수를 사용한다.

타입 파라미터 T 에 String 이 대입되었기 때문에 람다식의 t 매개 변수 타입은 String 이 된다.

Consumer<String> consumer = t -> { t 를 소비하는 실행문 ; };

BiConsumer<T, U> 인터페이스를 타겟 타입으로 하는 람다식은 다음과 같이 작성할 수 있다. accept() 메소드는 매개값으로

T 와 U 두 개의 객체를 가지므로 람다식도 두 개의 매개 변수를 사용한다. 타입 파라미터 T와 U 에 String 이 대입되었기 때문에 람다식의

t와 u 매개 변수 타입은 각각 String 이 된다.

BiConsumer<String, String> consumer =(t, u) -> { t와 u 를 소비하는 실행문 ; }

DoubleConsumer 인터페이스를 타겟 타입으로 하는 람다식은 다음과 같이 작성할 수 있다.

accept() 메소드는 매개값으로 double 하나를 가지므로 람다식도 한 개의 매개 변수를 사용한다.

d는 고정적으로 double 타입이 된다.

DoubleConsumer consumer =d -> { d를 소비하는 실행문 ;}

ObjIntConsumer<T> 인터페이스를 타겟 타입으로 하는 람다식은 다음과 같이 작성할 수 있다.

accept() 메소드는 매개값으로 T 객체와 int 값 두 개를 가지기 때문에 람다식도 두 개의 매개 변수를 사용한다. T 가 Stirng 타입이므로

람다식의 t 매개 변수 타입은 String 이 되고, i 는 고정적으로 int 타입이 된다.

ObjIntConsumer<String> consumer =(t, i) ->{ t 와 i 를 소비하는 실행문; }

public class ConSumerExample {

   public static void main(String[] args) {

       Consumer<String> consumer =t->System.out.println(t + "8");
       consumer.accept("java");

       BiConsumer<String, String> bigConsumer =(t, u) ->System.out.println(t+u);
       bigConsumer.accept("java", "8");

       DoubleConsumer doubleConsumer = d->System.out.println("Java" + d);
       doubleConsumer.accept(8.0);

       ObjIntConsumer<String> objIntConsumer =(t, i)->System.out.println(t+ i);
       objIntConsumer.accept("java", 8);

   }

}