[Java] 자바 predicate, consumer, supplier, function 이해하기 - 함수형 인터페이스 이해하기

함수형 인터페이스 Descriptor Method명

Funcation Interface	Descriptor	Method
Predicate<T>	T -> boolean	test()
Consumer<T>	T -> void	accept()
Supplier<T>	() -> T	get()
Function<T,R>	T -> R	apply()

 

predicate란

• 조건을 표현하는 인터페이스로, 함수형 인터페이스
• 인자를 하나 받아서, 해당 인자가 주어진 조건을 만족하는 여부를 boolean 값으로 반환합니다.
• 특정 조건에 맞는 데이터를 필터링하거나 검사하는 등의 작업에 사용됩니다.
  • 컬렉션에서 특정 조건에 맞는 요소를 필터링할 때 사용

public interface Predicate<T> {
		boolean test(T t);
}

Predicate<Integer> isEven = (n) -> n % 2 == 0;

System.out.println(isEven.test(4)); // true

public static List<Grape> filter(List<Grape> inventory, Predicate<Grape> p) {
    List<Grape> result = new ArrayList<>();
    for (Grape grape : inventory) {
        if (p.test(grape)) {
            result.add(grape);
        }
    }
    return result;
}

// ============
@Test
public void predicateTest() {
    System.out.println("Predicate Interface Test");
    filter(inventory, g -> g.getWeight() >= 100)
            .forEach(System.out::println);
}

 

consumer란

• 단일 인자를 받아서 어떤 처리를 하지만, 결과를 반환하지 않는 함수형 인터페이스
• 주어진 값을 사용해서 작업을 수행하고 끝나는 것이 특징입니다.

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

Consumer<String> printConsumer = (s) -> System.out.println(s);
printConsumer.accept("Hello Consumer");

public static void printGrapeInfo(List<Grape> inventory, Consumer<Grape> c) {
    for (Grape grape : inventory) {
        c.accept(grape);
    }
}

// ===============
@Test
public void consumerTest() {
    System.out.println("Consumer Interface Test");
    printGrapeInfo(inventory, System.out::println);
}

 

supplier란

• no requirement that a new
  • 인자를 받지 않고 결과를 반환하는 함수형 인터페이스
• distinct result be returned each time the supplier is invoked
  • 각 실행에 특정한 값이 반환됩니다.

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

Supplier<String> stringSupplier = () -> "Hello";
System.out.println(stringSupplier.get());

stringSupplier는 Supplier<String> 로서 문자열을 공급하는 역할을 하고, get() 을 호출하면 “Hello”를 반환합니다.

 

public static void eatGrape(Supplier<Grape> supplier) {
    Grape grape = supplier.get();
    System.out.println(grape.toString());
}

// =============
@Test
public void supplierTest() {
    System.out.println("Supplier Interface Test");
    eatGrape(() -> new Grape(100, "green"));
}

 

Function<T, R>

Represents a function that accepts one argument and producers a result
This is a functional interface whose functional method is apply(Object)

-> (하나의 argument와 결과를 생성하는 함수를 나타냄)

 

Funciton Interface는 인자를 하나 받아서 다른 타입의 결과를 반환하는 함수형 인터페이스입니다.

주로 하나의 입력을 받아 변환하거나 다른 결과를 도출할 때 사용합니다.

 

Type Parameters

• <T> : the type of the input to the function
  • 함수에 입력되는 타입 (처리하기 전 타입)
• <R> : the type of the result of the function
  • 함수의 결과 타입 (처리되는 타입)

public static List<String> getColorList(List<Grape> inventory, Function<Grape, String> function) {
    List<String> colorList = new ArrayList<>();
    for (Grape grape : inventory) {
        colorList.add(function.apply(grape));
    }
    return colorList;
}

// ========= //
@Test
public void functionTest() {
    getColorList(inventory, Grape::getColor)
            .forEach(System.out::println);
}

 

참고 자료

람다식과 스트림, 함수형 인터페이스(predicate, consumer, supplier, function, operator) 활용하기