1. 람다식이란?

• 메서드를 하나의 식으로 표현한 것으로 함수를 간략하면서도 명확한 식으로 표현할 수 있게 해준다.
• 메서드 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로, 람다식을 '익명함수'라고도 한다.

사용 방식

기존 코드

int max(int a, int b){
	return a > b ? a : b;
}

람다 적용

(a,b) -> a > b ? a : b;

2. 함수형 인터페이스

• 추상 메서드가 오직 하나인 인터페이스를 의미한다.
• @FunctionalInterface 어노테이션을 사용하는데, 이 어노테이션은 해당 인터페이스가 함수형 인터페이스 조건에 맞는지 검사해준다.
• 어노테이션이 없어도 동작은 하지만 인터페이스 검증과 유지보수를 위해 붙여주는게 좋다.

@FunctionalInterface
interface CustomInterface<T> {
    // abstract method 오직 하나
    T myCall();
}

(1) java.util.function 패키지

• 자주 사용하는 인터페이스들은 함수로 따로 만들어서 대중화하여 사용한다.
  

Runnable

• 아무런 객체를 받지고 않고 리턴도 하지 않는다.

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
-------- (람다식)
( ) --> void

Supplier

• 아무런 인자를 받지 않고 T타입의 객체를 리턴한다.

@FunctionalInterface
public interface Supplier<T> {
    T get();
}
-------- (람다식)
( ) --> T

Consumer

• 인자 하나를 받고 아무것도 리턴하지 않는다.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}
-------- (람다식)
T --> void

Function

• T타입 인자를 받아서 R타입을 리턴한다.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}
-------- (람다식)
T --> R

Predicate

• 인자 하나를 받아서 Boolean타입으로 리턴한다.
• 조건식에 사용함(true,false로 결과 출력)

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}
-------- (람다식)
T --> boolean

(2) 2개의 인자를 받는 Bi 인터페이스

• 매개변수가 2개인 함수형 인터페이스에는 Bi가 붙음
  

BiConsumer

• 2개를 입력받아 반환값은 없음

void accept(Integer i, Integer i2)
-------- (람다식)
(i,i2) -> void

BiPredicate

• 2개를 입력받아 비교하여 boolean으로 반환

boolean test(Integer i, Integer i2)
-------- (람다식)
(i,i2) -> boolean

BiFunction

• 2개를 비교받아 하나의 결과를 반환함

int apply(Integer i, Integer i2)
-------- (람다식)
(i,i2) -> int i3

3. 실습

interface 사용하여 람다 사용

interface StatementStrategy{
    boolean compare(int a, int b);
}

public class SelectionSort2 {
        static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public int[] solution(int[] arr,StatementStrategy stmt){
            int[] result = arr;

            for(int i=0; i<arr.length; i++){
                int minidx = i;
                for(int j=i; j<arr.length; j++){
                    if(stmt.compare(result[minidx],result[j]))        // interface를 통해 값만 구현후 원하는 식에 넣어 사용
                        minidx = j;
                }
                int temp = result[i];
                result[i] = result[minidx];
                result[minidx] = temp;
            }

            return result;
        }


    public static void main(String[] args) throws IOException {
        SelectionSort2 s = new SelectionSort2();
        String[] temp = br.readLine().split(" ");
        int[] arr = new int[temp.length];

        for(int i=0; i<temp.length; i++){
            arr[i] = Integer.parseInt(temp[i]);
        }
        System.out.println(Arrays.toString(s.solution(arr,(a,b) -> a>b)));
        System.out.println(Arrays.toString(s.solution(arr,(a,b) -> a<b)));

//        int[] r = s.solution(arr, new StatementStrategy() {
//            @Override
//            public boolean compare(int a, int b) {
//                return a>b;
//            }
//        });

    }
}

Function 사용하여 람다 사용

public class SelectionSort3 {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    public int[] solution(int[] arr, BiFunction<Integer,Integer,Boolean> stmt){
        int[] result = arr;

        for(int i=0; i<arr.length; i++){
            int minidx = i;
            for(int j=i; j<arr.length; j++){
                if(stmt.apply(arr[minidx],arr[j]))        // apply 결과값이 참일때 동작함
                    minidx = j;
            }
            int temp = result[i];
            result[i] = result[minidx];
            result[minidx] = temp;
        }

        return result;
    }


    public static void main(String[] args) throws IOException {

        SelectionSort3 s = new SelectionSort3();
        System.out.print("정렬할 값들을 입력하세요 :");
        String[] temp = br.readLine().split(" ");
        int[] arr = new int[temp.length];

        for(int i=0; i<temp.length; i++){
            arr[i] = Integer.parseInt(temp[i]);
        }

        BiFunction<Integer,Integer,Boolean> biFunction = (a,b) -> a>b;
        BiFunction<Integer,Integer,Boolean> biFunction2 = (a,b) -> a<b;

        System.out.println(Arrays.toString(s.solution(arr,biFunction)));
        System.out.println(Arrays.toString(s.solution(arr,biFunction2)));
    }
}

참고자료 : 자바의 정석