[JAVA] 람다식과 메소드참조 정리 (for Stream)

람다식

@FunctionalInterface
interface MyLambdaFunction {
    int max(int a, int b);
}

public class Main {

    public static void main(String[] args) {

        // 람다식을 이용한 익명함수
        MyLambdaFunction lambdaFunction = (int a, int b) -> a > b ? a : b;
        System.out.println(lambdaFunction.max(3, 5));
    }

}

 

 

람다식 메소드 참조

(x, y) -> Math.max(x, y)
(x, y) 중복 , 리턴 값이 또 다른 메서드 호출
Math::max;

@FunctionalInterface
interface IntBinaryOperation {
	int applyAsInt(int left, int right);
}

class Math {
	public static int max(int a, int b) {
    	return (a > b) ? a: b;
    }
}

//int가 대응되고 파라미터가 대응됌

public class Main {
	(main)
    // 함수형 인터페이스이기 때문에 이런식으로 직접 대입이 가능함
    	IntBinaryOperation b = Math::max;
}

 

메서드 참조 종료

종류	람다	메서드참조
정적 메서드 참조	(x) -> ClassName.method(x)	ClassName::method
인스턴스 메서드 참조	(x) -> obj.method(x)	obj::method
매개변수 메서드 참조	(obj, x) -> obj.method(x)	ClassName::method
생성자 참조	(x, y) -> new ClassName(x, y)	ClassName::new

 

 

정적 메서드 참조

Function<String, Integer> size;

// (obj, x) -> obj.method(x)  
size = (String s1) ->  s1.length();

// ClassName::method
size = String::length;

size.apply("Hello World"); // 11

 

 

생성자 참조

BiFunction<Integer, Integer, Object> constructor;

// (x, y) -> new ClassName(x, y)  
constructor = (x, y) -> new Object(x, y);

// ClassName::new
constructor = Object::new;

// 일반 람다식
List<Member> memberList = memberNameList.stream().map(name -> new Member(name)).collect(Collectors.toList());

// 메서드 참조 표현식
List<Member> memberList = memberNameList.stream().map(Member::new).collect(Collectors.toList());

 

 

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

Supplier<T>

• 매개변수 없이 반환값 만을 갖는 함수형 인터페이스

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

// 사용 예시
Supplier<String> supplier = () -> "Hello World!";
System.out.println(supplier.get());

 

 

Consumer<T>

• T를 매개변수로 받아서 사용하며, 반환값은 없는 함수형 인터페이스

public static void main(String args[]) {
  Consumer<Integer> consumer =
          (num) -> System.out.println(num + " * 10 = " + (num * 10));

  consumer.accept(100);
}

// 덧셈 → 뺄셈 → 곱셈 순서로 Consumer가 실행
public static void main(String args[]) {
  Consumer<Integer> consumerAdd =
          (num) -> System.out.println(num + " + 100 = " + (num + 100));

  Consumer<Integer> consumerMinus =
          (num) -> System.out.println(num + " - 100 = " + (num - 100));

  Consumer<Integer> consumerMultiple =
          (num) -> System.out.println(num + " * 100 = " + (num * 100));

  consumerAdd.andThen(consumerMinus.andThen(consumerMultiple)).accept(50);
}

 

 

Function <T, R>

• 객체 T를 매개변수로 받아서 처리한 후 R로 반환하는 함수형 인터페이스

// 정의
@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;
    }
}

// 예시, 메소드 참조로 간소화 가능(String::length;)
Function<String, Integer> function = str -> str.length();
function.apply("Hello World");

// 11 출력

 

 

 

Predicate<T>

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

// 예시
Predicate<String> predicate = (str) -> str.equals("Hello World");
predicate.test("Hello World");