2022/02/05 TIL

Thd Red : STREAM

Supplier

• 인자는 받을 수 없고 값을 리턴하기만 한다.
• 공식문서

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

예제 1)

    @Test
    void test_supplier(){
        Supplier<String> mySupplier = () -> "hello supplier";
        assertThat(mySupplier.get()).isEqualTo("hello supplier");
    }

mySupplier는 get()이라는 하나의 메서드만 가지고 있기 때문에 () -> "hello supplier"; 를 할당하면 get()에 할당이 되게 된다.

예제 2)

    @Test
    void test_supplier_with_method(){
        Supplier<String> mySupplier = () -> "hello supplier";
        process(mySupplier, 5);
    }

    void process(Supplier<String> mySupplier, int count){
        for (int i=0; i<count; i++){
            System.out.println(mySupplier.get() + " " + i);
        }
    }

mySupplier는 객체이기 때문에 1급 시민처럼 변수로 넘겨줄 수 있다.

Consumer

• 인자만 받고 리턴값이 없다.
• 공식문서

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

예제)

    @Test
    void test_consumer(){
        Consumer<String> myConsumer = str -> System.out.println(str);
        myConsumer.accept("hello");
    }

콘솔창에 "hello"가 출력된다.

BiConsumer

• Consumer와 비슷한데 인자를 2개 받는 점이 다르다.
• 공식문서

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);

    default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
        Objects.requireNonNull(after);

        return (l, r) -> {
            accept(l, r);
            after.accept(l, r);
        };
    }
}

예제)

    @Test
    void test_bi_consumer(){
        BiConsumer<Integer, Double> myBiConsumer = (index, input) -> {
            System.out.println("myBiConsumer " + input + " at index " + index);
        };
        List<Double> inputs = Arrays.asList(1.1, 2.2, 3.3);
        process(inputs, myBiConsumer);
    }

    <T> void process(List<T> inputs, BiConsumer<Integer, T> processor){
        for (int i=0; i < inputs.size(); i++){
            processor.accept(i, inputs.get(i));
        }
    }

출력값은 아래와 같다.

myBiConsumer 1.1 at index 0
myBiConsumer 2.2 at index 1
myBiConsumer 3.3 at index 2

Consumer와 거의 비슷하다. inputs 타입을 바꾸며 사용하면 효율적으로 사용할 수 있어 보인다.

제네릭 메서드

매개 변수에 제네릭 타입을 사용하고 싶을 때는 리턴값 옆에 제네릭을 작성해주면 된다.

예시)

    <T> void process(List<T> inputs){
    }