FunctionalInterface

sixhustle·2022년 3월 14일
0

Java

목록 보기
3/10

Lambda

람다식(Lambda Expression)은 메소드를 직접 정의하지 않고, 하나의 '식'으로 표현한 것이다.

람다식은 불필요한 코드를 줄이고, 가독성을 높이기 위해 사용!

//	method block
public int sum(int a, int b) {
   return a + b;
}

//	lambda
(int a, int b) -> {
   return a + b;
}
(int a, int b) -> { return a + b; }
(int a, int b) -> a + b;
(a, b) -> a + b;

FunctionalInterface

오직 하나의 method 선언을 갖는 interface로 함수를 일급객체처럼 다룰 수 있게 도와주는 것이다.
람다식은 FunctionalInterface 기반으로만 작성이 가능하다.

일급객체(First Class Citizen)

  • 변수에 값을 할당할 수 있어야 한다.
  • 함수의 파라미터로 넘겨줄 수 있어야 한다.
  • 함수의 반환값이 될 수 있어야 한다.

예제

@FunctionalInterface
interface Calculate {
   int sum(int a, int b);
   // default int plus(int a, int b) { return a + b; }
   // static int sub(int a, int b) { return a - b; } 
}

Java에서 제공하는 FunctionalInterface

Supplier

매개변수 없이 반환 값만을 가지는 인터페이스

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

Consumer

T 매개변수를 받으며, 반환 값은 없다. andThen을 사용하여 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); }; 
   } 
}

Function

@FunctionalInterface 
public interface Function<T, R> { 
   R apply(T t); 
   default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { 
      Objects.requireNonNull(before); 
      return (V v) -> apply(before.apply(v)); 
   } 
   default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { 
      Objects.requireNonNull(after); 
      return (T t) -> after.apply(apply(t)); 
   } 
   static <T> Function<T, T> identity() { return t -> t; } }

Predicate

@FunctionalInterface 
public interface Predicate<T> { 
   boolean test(T t); 
   default Predicate<T> and(Predicate<? super T> other) {
      Objects.requireNonNull(other); 
      return (t) -> test(t) && other.test(t); 
   } 
   default Predicate<T> negate() { 
      return (t) -> !test(t); 
   } 
   default Predicate<T> or(Predicate<? super T> other) {
      Objects.requireNonNull(other); 
      return (t) -> test(t) || other.test(t); 
   } 
   static <T> Predicate<T> isEqual(Object targetRef) { 
      return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); 
   } 
}

Reference

0개의 댓글