java.util.function 패키지

java.util.function 패키지

자주 사용되는 다양한 함수형 인터페이스를 제공

함수형 인터페이스	메서드	설명
java.lang.Runnable	void run()	매개변수도 없고, 반환값도 없음
Supplier	T get()	매개변수는 없고, 반환값만 있음
Consumer	void accept(T t)	매개변수만 있고, 반환값이 없음
Function<T, R>	R apply(T t)	일반적인 함수. 하나의 매개변수를 받아서 결과 반환
Predicate	boolean test(T t)	매개변수는 하나, 반환 타입은 boolean

Predicate<String> isEmptyStr = s -> s.length()==0;
String s = "";

if (isEmpthStr.test(s))
	System.out.println("This is an empty string!");

Q. 빈 칸에 알맞은 함수형 인터페이스(java.util.function 패키지)를 적어보자

[ Supplier< Integer > ] f = () -> (int)(Math.random()*100) + 1;

[ Consumer< Integer >] f = i -> System.out.println(i+", ");

[ Predicate < Integer > ] f = i -> i%2==0;

[ Function < integer, Integer > ] f = i -> i/10*10;

매개변수가 2개인 함수형 인터페이스

함수형 인터페이스	메서드	설명
BiConsumer<T, U>	void accept(T t, U u)	두 개의 매개변수만 있고, 반환값이 없음
BiPredicate<T, U>	boolean test(T t, U u)	매개변수는 둘, 반환값은 Boolean
BiFunction<T, U, R>	R apply(T t, U u)	두 개의 매개변수를 받아서 하나의 결과를 반환

만약 매개변수를 3개를 받는 함수형 인터페이스를 만들고 싶다면?

직접 만들면 된다!

@FunctionalInterface
interface TriFunction<T,U,V,R> {
  R apply(T t, U u, V v);
}

보통 한개나 두개가 많아서 여기까지는 만들어놓지만, 세개 이상부터는 필요하면 만들어서 써라!
대신 매개변수가 하나나 두개일 때는 만들지 말고, 미리 만들어놓아준 것을 쓰라!

매개변수의 타입과 반환 타입이 일치하는 함수형 인터페이스

함수형 인터페이스	메서드	설명
UnaryOperator	T apply(T t)	Function의 자손. Function과 달리 매개변수와 결과의 타입이 같다
BinaryOperator	T apply(T t, T t)	BiFunction의 자손, BiFunction과 달리 매개변수와 결과의 타입이 같다

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

    /**
     * Returns a unary operator that always returns its input argument.
     *
     * @param <T> the type of the input and output of the operator
     * @return a unary operator that always returns its input argument
     */
    static <T> UnaryOperator<T> identity() {
        return t -> t; // 항등함수
    }
}

활용

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class MyFunctionalInterface {
    public static void main(String[] args){
        // Supplier
        Supplier<Integer> s = () -> (int)(Math.random()*100) + 1; // 1 ~ 100
        // Consumer
        Consumer<Integer> c = i -> System.out.println(i+", "); // print Console
        // Predicate
        Predicate<Integer> p = i -> i %2==0; // check even number
        // Function
        Function<Integer, Integer> f = i -> i/10 * 10; // eliminate units

        List<Integer> list = new ArrayList<>();
        makeRandomList(s, list);
        System.out.println(list);
        printEvenNumber(p,c,list);
        List<Integer> newList = doSomething(f, list);
        System.out.println(newList);
    }

    private static <T> List<T> doSomething(Function<T, T> f, List<T> list) {
        List<T> newList = new ArrayList<T>(list.size());
        for (T i : list){
            newList.add(f.apply(i));
        }
        return newList;
    }

    private static <T>  void printEvenNumber(Predicate<T> p, Consumer<T> c, List<T> list) {
        System.out.println("[");
        for(T i : list){
            if ( p.test(i)){
                c.accept(i);
            }
        }
        System.out.println("]");
    }

    private static void makeRandomList(Supplier<Integer> s, List<Integer> list) {
        for(int i=0; i<10; i++) {
            list.add(s.get()); // From Supplier
        }
    }
}