자바에서 제공하는 함수형 인터페이스

Function<T,R>

• T타입을 받아서 R타입을 리턴하는 함수 인터페이스

사용 방법 1

public class Plus10 implements Function<Integer, Integer> {
    @Override
    public Integer apply(Integer integer) {
        return integer + 10;
    }
}


public class Foo {
    public static void main(String[] args) {
        Plus10 plus10 = new Plus10 ();
        System.out.println (plus10.apply ( 1 ));
    }
}

사용 방법 2

import java.util.function.Function;

public class Foo {
    public static void main(String[] args) {
    	//람다 표현식을 사용하여 클래스 필요 없이 바로 구현 가능
        Function<Integer, Integer> plus10 = (i) -> i + 10;
        System.out.println (plus10.apply ( 1 ));
    }
}

함수 조합용 메서드

• compose
• andThen

import java.util.function.Function;

public class Foo {
    public static void main(String[] args) {
        Function<Integer, Integer> plus10 = (i) -> i + 10;
        Function<Integer, Integer> multiply2 = (i) -> i * 2;

        //함수를 조합할 수 있는 메서드를  default 메서드로 제공한다
        //compose 사용하면 x2 먼저 실행 후 +10 실행
        Function<Integer, Integer> multiply2AndPlus10 = plus10.compose(multiply2);
        System.out.println (multiply2AndPlus10.apply (2));
        // andThen? +10 실행 후 x2 실행
        Function<Integer, Integer> Plus10AndMultiply2 = plus10.andThen(multiply2);
        System.out.println(Plus10AndMultiply2.apply(2));
    }
}

 

 

BiFuntion<T, U, R>

• 두 개의 값(T, U)를 받아서 R 타입을 리턴하는 함수 인터페이스

import java.util.function.BiFunction;

public class BiFunctionExample1 {

    public static void main(String[] args) {

        BiFunction<String, String, String> func1 = (s1, s2) -> {
            String s3 = s1 + s2;
            return s3;
        };
        String result = func1.apply("Hello", "World");
        System.out.println(result);

        BiFunction<Integer, Integer, Double> func2 = (a1, a2) -> Double.valueOf(a1 + a2);
        Double sum = func2.apply(10, 100);
        System.out.println(sum);
    }
}

 

 

Consumer<T>

• T 타입을 받아서 아무값도 리턴하지 않는 함수 인터페이스

public class Foo {
    public static void main(String[] args) {
        Consumer<Integer> printT = (i) -> System.out.println (i);
        printT.accept (10);
    }
}

 

 

Supplier<T>

• T 타입의 값을 제공하는 함수 인터페이스

import java.util.function.Supplier;

public class Foo {
    public static void main(String[] args) {
        Supplier<Integer> get10 = () -> 10;
        System.out.println(get10.get());
    }
}

 

 

Predicate<T>

• T 타입을 받아서 beelean을 리턴하는 함수 인터페이스

함수 조합용 메소드

• And, Or, Negate

public class Foo {
    public static void main(String[] args) {
        // true false 를 리턴해주는 함수
        Predicate<String> startsWithKeesun = (s) -> s.startsWith ("keesun");
        Predicate<Integer> isEven = (i) -> i % 2 == 0;
    }
}

 

 

UnaryOperator<T>

• Function<T, R>의 특수한 형태로, 입력값 하나를 받아서 동일한 타입을 리턴하는 함수 인터페이스

import java.util.function.UnaryOperator;

public class Foo {
    public static void main(String[] args) {
        // Function 상속받아서 사용한다. 
        // compose, andThen 사용이 가능하다
        UnaryOperator<Integer> plus10 = (i) -> i + 10;

        System.out.println ( plus10.apply(2));
    }
}

 

 

BinaryOperator<T>

• BiFunction<T, U, R>의 특수한 형태로, 동일한 타입의 입력값 두개를 받아 리턴하는 함수 인터페이스

import java.util.function.BinaryOperator;

public class Foo {
  public static void main(String[] args) {
    // BiFunction 에 특수한 형태로, 세개의 타입이 모두 같은경우 쓰일수 있다는 것이다.
    BinaryOperator<Integer> test = (a,b) -> a + b + 20;
  }
}

 

 

 

참고 자료

---

백기선 - 더 자바, Java8
https://www.inflearn.com/course/the-java-java8/dashboard