[JAVA] 람다식, 함수형 인터페이스

 람다식 

익명 클래스의 생성과 정의를 간단하게 표현

 

람다식 작성

• 하나의 추상 메소드를 정의하고 있는 인터페이스에서 사용
• -> 로 선언부와 매개변수 나눔
• 메서드의 이름과 반환 타입 없음
• 매개변수의 타입 생략 가능
• 매개변수가 하나면 매개변수를 감싸는 괄호() 생략 가능
• 다른 명령없이 바로 리턴한다면 메소드 정의 부분인 중괄호{}와 return 키워드 생략 가능

하나의 추상메서드를 가진 인터페이스 작성

public interface Addition {
    int add(int x, int y);
}

인터페이스 구현

1. 익명클래스로 구현

2. 람다식으로 구현

public class AdditionMain {
    public static void main(String[] args) {
    	//1. 익명클래스
        Addition addition = new Addition() {
            @Override
            public int add(int x, int y) {
                return x + y;
            }
        };
        System.out.println("결과 : " + addition.add(10,20));
        
	//2. 람다식
        Addition addition2 = (x, y) -> x + y;
        System.out.println("결과2 : " + addition2.add(10, 20));
    }
}

---

 

함수형 인터페이스

 

하나의 추상 메서드를 가지는 인터페이스

 

함수형 인터페이스 선언

@FunctionalInterface

• 함수형 인터페이스라는 의미
• 메서드를 두 개 이상 선언 시 오류를 발생 시킴

@FunctionalInterface
public interface 인터페이스명{
	반환타입 메서드명(매개변수...);
}

 

함수형 인터페이스 종류

자바에서 제공하는 기본 함수형 인터페이스

함수형 인터페이스	메서드	매개변수	반환값
Runnable	void run()	없음	없음
Supplier<T>	T get()	없음	있음
Consumer<T>	void accept(T t)	있음	없음
Function<T, R>	R apply(T t)	있음	있음
Redicate<T>	boolean test(T t)	있음	있음

 

1. Runnable

//익명클래스
Runnable runnable = new Runnable() {
	@Override
	public void run() {
		System.out.println("프로그램 실행");
	}
};

//람다식
Runnable runnable = () -> System.out.println("프로그램 실행");

//메서드 실행
runnable.run();

 

2. Supplier<T>

//익명클래스
Supplier<Integer> supplier = new Supplier<Integer>() {
	@Override
	public Integer get() {
		return 999;
	}
};

//람다식
Supplier<Integer> supplier = () -> 999;

//메서드 사용
supplier.get();

 

3. Consumer<T>

//익명클래스
Consumer<Integer> consumer = new Consumer<Integer>() {
	@Override
	public void accept(Integer n) {
		System.out.println("n : " + n);
	}
};

//람다식
Consumer<Integer> consumer = n -> System.out.println("n : " + n);

//메서드 사용
consumer.accept(10);

 

4. Function<T, R>

//익명클래스
Function<String, Integer> fx = new Function<String, Integer>() {
	@Override
	public Integer apply(String s) {
		return Integer.parseInt(s) + 10;
	}
};

//람다식
Function<String, Integer> fx = s -> Integer.parseInt(s) + 10;

//메서드 사용
fx.apply("10")

 

andThen 메서드

 

Function 인터페이스에는 andThen이라는 기본 메서드가 존재한다.

 

추상메서드를 먼저 익명클래스로 작성하고 사용할 수 있다.

Function<String, Integer> fx = s -> Integer.parseInt(s);
Integer num = fx.andThen(n -> n + 10).apply("10");

 

andThen메서드는 매개변수로 Function 함수형 인터페이스를 받는다.

 

실행 순서는 apply가 먼저 실행되어 문자열 "10" 이 Integer형으로 변환되고 andThen메서드의 n 매개변수에 대입된다.

 

5. Predivate<T>

//익명클래스
Predicate<Integer> predicate = new Predicate<Integer>() {
	@Override
	public boolean test(Integer n) {
		return n % 2 == 0;
	}
};

//람다식
Predicate<Integer> predicate = n -> n % 2 == 0;

//메서드 사용
predicate.test(10);

 

Comparator 함수형 인터페이스

두 개의 객체를 비교

//익명클래스
Comparator<Integer> comparator = new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		return o1 - o2;
	}
};

//람다식
Comparator<Integer> comparator = (o1, o2) -> o1 - o2;

두 개의 객체를 비교해서 리턴값이 양수면 앞, 뒤를 변경하고 0이나 음수면 변경하지 않는다.

 

리턴부분에 정렬하고자하는 기준에 맞게 값을 지정하면 된다.