함수형 인터페이스 정리

함수형 인터페이스

• 함수형 인터페이스란 1개의 추상 메소드를 갖는 인터페이스를 말한다
• 여러개의 디폴트 메서드가 있어도 추상메서드가 하나라면 함수형 인터페이스다.
• 람다 표현식은 함수형 인터페이스로만 사용이 가능하다.

@FunctionalInterface

해당 인터페이스가 ㅎ마수형 이터페이스에 조건에 맞는지 검사해준다.

@FunctionalInterface
interface Test<T>{

	// 추상 메서드
	T testMethod()
	
   // 디폴트 메서드
	default void printDefault() {
   		System.out.println("Hello Default");
	}

	// static 메서드
	static void printStatic() {
   		System.out.println("Hello Static");
	}

Predicate

test라는 추상 메서드를 정의하며 제네릭 형식 T의 객체를 인수로 받아 불리언을 반환한다.
검증할떄 많이 사용되며 스트림의 filter에서 주로 사용

• 함수형 인터페이스 : Predicate
• 함수 디스크립터 : T -> boolean
• 기본형 특화 : IntPredicate, longPredicate, DoublePredicate

@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);
    }
    @SuppressWarnings("unchecked")
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

public class Main {

    public static void main(String[] args) {
        IntPredicate intPredicate1 = d ->  d >= 100;
        IntPredicate intPredicate2 = d -> d%2 == 0;

        boolean check1 = intPredicate1.test(23);
        boolean check2 = (intPredicate1.and(intPredicate2).test(20));
    }
}

Consumer

accept라는 추상 메서드를 정의하며 제네릭 형식 T의 객체를 인수로 받아 void를 반환한다.
소비자로 인수를 받고 기턴 값은없다. BiConsumer<T,T>를 사용함으로써 인수를 두개받을 수 있음, 3개 이상부터는 함수형 인터페이스를 만들어 사용가능

• 함수형 인터페이스 : Consumer
• 함수 디스크립터 : T -> void
• 기본형 특화 : IntConsumer, longConsumer, DoubleConsumer

@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); };
    }
}

public class Main {

	public static void main(String[] args) {
	
		
		Consumer<List<Integer>> listConsumer = l -> {
			for (int i = 0; i < l.size(); i++) {
				l.set(i, l.get(i) * 3);
			}
		};
		Consumer<List<Integer>> print = l -> {
			for (Integer num : l) {
				System.out.println(num);
			}
		};
		List<Integer> moneys = Arrays.asList(100, 5000, 10000);
		listConsumer.andThen(print).accept(moneys);

	}

}

Function<T,R>

apply라는 추상 메서드를 정의하며 제네릭 형식 T의 객체를 인수로 받아 R 타입의 객체를 반환한다.
BiFunction<T,V,R>를 사용함으로써 파리미터를 두개까지 받을 수 있고 3개 이상부터는 함수형 인터페이스로 만들 수 있다.

• 함수형 인터페이스 : Function<T,R>
• 함수 디스크립터 : T -> R
• 기본형 특화 : IntFunction, IntToDoubleFunction, IntToLongFunction....

Function을 상속받은 인터페이스

• UnaryOperator
  • Function<T,T>를 상속받은 인터페이스
  • T값을 받아 T값을 반환한다.
• BinaryOperator
  • Function<T,T,T>를 상속받은 인터페이스
  • T값을 두개 받아 T값을 반환한다.

@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;
    }
}

public class Main {
	public static void main(String[] args) {
	
		Function<String, Integer> chageFunction = str -> str.length();
        System.out.println(chageFunction.apply("람다공부우우우"));
        

        Function<Integer, Integer> changeFunction2 = number -> number *2;
        Integer result = chageFunction.andThen(changeFunction2).apply("람다공부우우우");
        System.out.println(result);
	}

}

Supplier

get라는 추상 메서드를 정의하며 인자를 받지않고 T 타입의 객체를 반환한다.
공급자로 파라미터는 받지 않고 리턴값만 있다.

• 함수형 인터페이스 : Supplier
• 함수 디스크립터 : () -> T
• 기본형 특화 : BooleanSupplier, LongSupplier, DoubleSupplier, IntSupplier

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


@FunctionalInterface
public interface BooleanSupplier {
    boolean getAsBoolean();
} 

public class Main {

	public static void main(String[] args) {
	
		Supplier<String> supplier= () -> "람다 공부우우우우";
        System.out.println(supplier.get());
        
        BooleanSupplier boolean11 = () ->  "람다 공부우우우우".length() > 5;
        System.out.println(boolean11.getAsBoolean());
	}

}