Java Interface (6) - 제네릭을 이용한 Consumer, Predicate 패턴

//MyConsumer.java
@FunctionalInterface
public interface MyConsumer<T> {
    void consume(T t);
}

//MyMapper.java
@FunctionalInterface
public interface MyMapper<IN, OUT> {
    OUT map(IN s);
}

//MySupplier.java
@FunctionalInterface
public interface MySupplier<T> {
    T supply();
}

//Main.java
public class Main {
    public static void main(String[] args) {
        MySupplier<String> s = () -> "Hello World!";
        MyMapper<String, Integer> m = String::length; //제네릭에서는 primitive타입을 사용할 수 없다.
        MyMapper<Integer, Integer> m2 = i -> i*i;
        MyMapper<Integer, String> m3 = Integer::toHexString;
        MyConsumer<String> c = System.out::println;
        
        MyRunnable r = () ->
                c.consume(
                    m3.map(
                        m2.map(
                            m.map(
                                s.supply()
                            )
                        )
                    )
                );
        r.run();
    }
}

//Main2.java
public class Main2 {
    public static void main(String[] args) {
    }
    
    void loop(int n, MyConsumer<Inrteger> consumer) {
        for (int i = 0; i < n; i++) {
            // 어떠한 동작을 정의함.
            // 입력은 있고, 출력은 따로 없어도 될 때 Consumer 를 이용한다.
            consumer.consume();
        }
    }
}

 

---

Consumer

어떠한 동작을 외부에서 주입해줄 때 사용한다.

 

Predicate

어떠한 동작을 통해 true/false를 반환하는 것을 주입해줄 때 사용한다.

//Main3.java
public class Main3 {
    public static void main(String[] args) {
        new Main3().filteredNumbers(30,
            i -> i % 2 == 0, // 짝수일 때 true
            i -> System.out::println // System.out.println 동작 주입
        );
    }
    void filteredNumbers(int max, Predicate<Integer> p, Consumer<Integer> c) {
        for (int i = 0; i < max; i++) {
            if (p.test(i)) c.accept(i);
        }
    }
}