이번 포스팅에서는 Java SE 가 제공하는 내장라이브러리의 java.util.function 의 함수형 인터페이스들에 대해 junit5 테스트 코드를 작성해 가며 간단히 알아보도록 하겠다.
Interface Function<T,R>
T - the type of the input to the function
R - the type of the result of the function
T 타입의 데이터를 입력받아, R 타입의 데이터를 출력하는 함수형 인터페이스이다.
@Test
@DisplayName("Function<T,R> 인터페이스 테스트")
void testFunctionInterface(){
// Integer 를 입력값으로 함수를 수행 후 Double return
Function<Integer, Double> func = (i) -> {
return Double.valueOf(i);
};
assertThat(func.apply(10)).isEqualTo(Double.valueOf(10));
}java.util.function 의 Function 인터페이스의 주요 메서드들을 살펴보면
apply(T t)
Applies this function to the given argument.
--> T 타입의 t 를 함수의 입력값으로 받아 함수를 실행
compose(Function<? super V,? extends T> before)
Returns a composed function that first applies the before function to its input, and then applies this function to the result.
--> input 으로 받은 값으로 before 함수를 수행한 후 그 결과값 input으로 받아 수행하는 합성함수를 return
andThen(Function<? super R,? extends V> after)
Returns a composed function that first applies this function to its input, and then applies the after function to the result.
--> input 을 받아 함수를 수행한 후 그 결과값을 after 함수의 input 으로 넣어 수행하는 합성함수를 return
@Test
@DisplayName("Function<T,R> 의 compose(), andThen() 메서드 테스트")
void funcIntCompose(){
Function<Integer, Integer> plus10 = (i) -> i+10;
Function<Integer, Integer> multiplyBy2 = (i) -> i * 2;
assertThat(plus10.apply(2)).isEqualTo(12);
assertThat(multiplyBy2.apply(2)).isEqualTo(4);
// input 받은 2를 multiplyBy2 의 입력값으로 multiplyBy2 함수를 수행한 후, 그 결과값을 plus10의 입력값으로 하여 함수를 수행
assertThat(plus10.compose(multiplyBy2).apply(2)).isEqualTo(14);
// input 받은 2를 수행한 결과값을 multiplyBy2 함수의 input 으로 하여 multiplyBy2 수행
assertThat(plus10.andThen(multiplyBy2).apply(2)).isEqualTo(24);
}
Interface BiFunction<T, U, R>
T - the type of the first argument to the function
U - the type of the second argument to the function
R - the type of the result of the function
--> T 와 U 타입의 데이터를 입력받아 R 타입의 데이터를 출력하는 함수형 인터페이스
apply(T t, U u)
Applies this function to the given arguments.
--> Function<T> 의 apply() 와 유사한 메서드지만 파라미터가 2개이다.
@Test
@DisplayName("BiFunction<T, U, R> 의 apply()")
void biFunctionApply(){
BiFunction<String, String, String> stringConcat = (s1, s2) -> s1+s2;
assertThat(stringConcat.apply("hello", " world")).isEqualTo("hello world");
}andThen(Function<? super R,? extends V> after)
Returns a composed function that first applies this function to its input, and then applies the after function to the result.
--> Function<T> 의 andThen() 과 유사한 메서드
@Test
@DisplayName("BiFunction<T, U, R> 의 andThen()")
void biFunctionAndThe(){
BiFunction<String, String, String> stringConcat = (s1, s2) -> s1+s2;
Function<String, String> stringConcat2 = (s) -> s + " !!!";
assertThat(stringConcat.andThen(stringConcat2).apply("hello", " world")).isEqualTo("hello world !!!");
}Interface Consumer<T>
T - the type of the input to the operation
T 타입의 데이터를 Input 으로 받는 수행 (리턴 없음)
@Test
@DisplayName("Consumer<T> 인터페이스 테스트")
void consumerTest(){
Consumer<String> HelloToName = (name) -> System.out.println("Hello " + name);
HelloToName.accept("jaden");
}
------- console
Hello jadenaccept(T t)
Performs this operation on the given argument.
-> T 타입의 t 로 opertaion 수행
andThen(Consumer<? super T> after)
Returns a composed Consumer that performs, in sequence, this operation followed by the after operation.
-> consumer 작업을 수행한 후 순차적으로 after consumer 수행
@Test
@DisplayName("Consumer<T> 의 andThen() 테스트")
void consumerAndThen() {
Consumer<String> HelloToName = (name) -> System.out.println("Hello " + name);
Consumer<String> ByeToName = (name) -> System.out.println("Bye " + name);
HelloToName.andThen(ByeToName).accept("jaden");
}
------- console
Hello jaden
Bye jadenInterface Supplier <T>
T - the type of results supplied by this supplier
-> T 타입의 결과 반환
get()
Gets a result.
-> 결과 반환
@Test
@DisplayName("Supplier<T> 의 get()")
void supplierTest(){
String expectedToSupplied = "supply this!";
Supplier<String> supplier = () -> expectedToSupplied;
assertThat(supplier.get()).isEqualTo(expectedToSupplied);
}Interface Predicate<T>
T - the type of the input to the predicate
--> T 타입의 input 을 가진다.
Represents a predicate (boolean-valued function) of one argument.
--> 인자의 boolean-value 를 나타낸다.
test(T t)
Evaluates this predicate on the given argument.
--> 주어진 인자의 boolean-value를 반환할 predicate 실행
@Test
@DisplayName("Predicate<T> 의 test()")
void predicateTest(){
Predicate<String> startWithJaden = (s) -> s.startsWith("Jaden");
assertThat(startWithJaden.test("Jaden")).isTrue();
assertThat(startWithJaden.test("SomethingElse")).isFalse();
}or(Predicate<? super T> other)
Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another.
--> 'other' predicate 반환값 불린과 지금의 predicate 반환값 불린의 short-circuiting logical OR(즉, || ) 연산 결과를 반환
@Test
@DisplayName("Predicate<T> 의 or(Predicate<? super T> other)")
void predicateOr(){
Predicate<Integer> isOdd = (i) -> i % 2 == 1;
Predicate<Integer> isIntegerThree = (i) -> i.equals(Integer.valueOf(3));
assertThat(isOdd.test(1)).isTrue();
assertThat(isOdd.test(2)).isFalse();
assertThat(isIntegerThree.test(3)).isTrue();
assertThat(isIntegerThree.test(1)).isFalse();
assertThat(isOdd.or(isIntegerThree).test(1)).isTrue();
assertThat(isOdd.or(isIntegerThree).test(2)).isFalse();
assertThat(isOdd.or(isIntegerThree).test(3)).isTrue();
}negate()
Returns a predicate that represents the logical negation of this predicate.
--> 해당 predicate 의 반대결과 (즉, !) 를 반환
@Test
@DisplayName("Predicate<T> 의 negate()")
void predicateNegate(){
Predicate<Integer> isIntegerOne = (i) -> i.equals(Integer.valueOf(1));
assertThat(isIntegerOne.negate().test(1)).isFalse();
}isEqual(Object targetRef)
Returns a predicate that tests if two arguments are equal according to Objects.equals(Object, Object).
--> 음.. 코드로 보는게 훨씬 편할 것이다.
@Test
@DisplayName("Predicate<T> 의 isEqual()")
void predicateIsEqual(){
Predicate<String> predicate = Predicate.isEqual("test1");
assertThat(predicate.test("test1")).isTrue();
assertThat(predicate.test("test2")).isFalse();
}and(Predicate<? super T> other)
Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another.
-->'other' predicate 반환값 불린과 지금의 predicate 반환값 불린의 short-circuiting logical OR(즉, || ) 연산 결과를 반환
java.util.fucntion 이 제공하는 함수형 인터페이스들 중 5개의 함수형 인터페이스를 살펴보았다. 이외에도 다양한 함수형 인터페이스를 제공하고 있으니, 래퍼런스를 직접 공부해보도록 하자!
참고 : 더 자바, Java8 강의, Java SE API
