[JAVA] 람다(Lamda)

 

람다(Lamda)

- 람다 표현식은 메소드로 전달할 수 있는 익명 함수를 단순화한 코드의 블록

- 람다 표현식은 특정 클래스에 종속되지 않으며 함수라는 이름으로 명명

- 람다 표현식은 함수 자체를 전달 인자로 보내거나 저장하는 것이 가능함

- 람다 표현식은 익명 구현 클래스를 생성하고 객체화 함

- 익명 구현 클래스로 생성된 람다 표현식은 인터페이스로 대입 가능하며 이 인터페이스를 함수형 인터페이스라고 함

- 람다표현식 :: () -> { }

 

함수형 인터페이스
- 하나의 디폴트 메소드를 갖는 인터페이스(다수의 디폴트 메소드를 갖더라도 하나의 디폴트 메소드라면 함수형 인터페이스)
- 함수형 인터페이스는 @FunctionalInterface 애노테이션을 이용해 컴파일 검사 가능
- 함수형 인터페이스의 추상메소드 시그니처를 함수 디스크립처(Function Descriptor)라고 함 

	입력	출력	메소드
Predicate	O	boolean	boolean test(T t0
Consumer	O	X	void accept(T t)
Function	O	O	T apply(U u)
Supplier	X	O	T get()
Operator	O	O	T apply(T t)

 

Predicate

함수형 인터페이스	정의메서드	파라미터	리턴
Predicate<T>	boolean test(T t){       return true; }	T	boolean
BiPredicate<T, U>	boolean test(T t, U u){       return true; }	T, U	boolean
IntPredicate	boolean test(int t){       return true; }	T	boolean
DoublePredicate	boolean test(double d){       return true; }	T	boolean
LongPredicate	boolean test(double d){       return true; }	X	boolean

 

Consumer

함수형 인터페이스	정의메서드	파라미터	리턴
Consumer<T >	void. accept(T t){ }	T	X
BiConsumer<T, U>	void accept(T t, U u){ }	T, U	X
IntConsumer	void accept(int i){ }	int	X
DoubleConsumer	void accept(double d){ }	double	X
LongConsumer	void accept(long l){ }	long	X
ObjIntConsumer<T>	void accept(T t, int i){ }	T, int	X
ObjDoubleConsumer<T>	void accept(T t, double d){ }	T, double	X
ObjLongConsumer<T>	voud accept(T t, long l){ }	T, long	X

 

Function

함수형 인터페이스	정의메서드	파라미터	리턴
Function<T , R>	R apply(T t){       return R; }	T	R
BiFunction<T, U, R>	R apply(T t, U u){       return R; }	T, U	R
IntFunction<R>	R apply(int i){       return R; }	int	R
DoubleFunction<R>	R apply(double d){       return R; }	double	R
LongFunction<R>	R apply(long l){       return R; }	long	R
IntToDoubleFuncion	double applyAsDouble(int i){     return double; }	int	double
IntToLongFunction	long applyAsLong(int i){    return long; }	int	long
LongToDoubleFunction	double applyAsDouble(long l){     return double; }	long	double
LongToIntFunction	int applyAsLong(long l){   return int; }	long	int
ToDoubleBiFunction<T, U>	double applyAsDouble(T t, U u){   return double; }	T, U	double
ToDoubleFunction<T>	double applyAsDouble(T t){    return double; }	T	double
ToIntBiFunction<T, U>	int applyAsInt(T t, U u){    return int; }	T, U	int
ToIntFuntion<T>	int applyAsInt(T t){    return int; }	T	int
ToLongBiFunction<T, U>	long applyAsLong(T t, U u){    return long; }	T, U	long
ToLongFunction<T>	long applyAsLong(T t){    return long; }	T	long

 

Supplier

함수형 인터페이스	정의메서드	파라미터	리턴
Supplier<T>	T get(){     return T; }	X	T
BooleanSupplier	boolean getAsBoolean(){    return boolean; }	X	boolean
DoubleSupplier	double getAsDouble(){    return double; }	X	double
IntSupplier	int getAsInt(){     return int; }	X	int
LongSupplier	long getAsLong(){    return long; }	X	long

 

Operator

함수형 인터페이스	정의메서드	파라미터	리턴
UnaryOperator<T> * Function<T, T> 인터페이스를 상속받음
BinaryOperator * BiFunction<T, T, T> 인터페이스를 상속받음

 

 

List<String> list = new ArrayList<>();
list.add("red");
list.add("blue");
list.add("green");

/* 람다표현식을 사용하지 않을 경우 예시 */
for(String s : list){
	System.out.println(s);
}
 
 
/* 람다표현식을 사용한 예시 */

//(1) 
list.stream().forEach((String s)->{System.out.println(s);});

//(2) 실행문이 한 줄로 표현될 경우 '{}' 생략가능
list.stream().forEach((String s)-> System.out.println(s));   

//(3) list의 요소 타입을 'List<String>'으로 선언해서 사용되었기에
//	  파라미터의 타입을 유추 할 수 있는 경우 파라미터 타입 생략 가능
list.stream().forEach(s -> System.out.println(s));

//(4)
list.stream().forEach(System.out::println);

 

Runnable runnable = new Runnable() {
	@Override
    public void run() {
    }
}

 

      : 

 

참고1 : 나무소리 인강 5-7강 스트림의 이해 

참고2:

https://inpa.tistory.com/entry/%E2%98%95-%ED%95%A8%EC%88%98%ED%98%95-%EC%9D%B8%ED%84%B0%ED%8E%98%EC%9D%B4%EC%8A%A4-API

☕ 함수형 인터페이스 표준 API 총정리