람다식(Lambda Expression) - (2)

  앞에 글에 이어서 람다식을 살펴보자. 이번에는 java.util.function 패키지의 함수형 인터페이스와 메서드 참조에 대해서 알아볼 것이다.

 

1. 함수형 인터페이스 🍛

  함수형 인터페이스에 대한 설명이 필요하다면 앞의 글을 참고하기를 바란다. 여기서는 java.util.function에서 제공하는 함수형 인터페이스의 종류와 사용법에 대해서만 알아보고자 한다.

함수형 인터페이스	메서드	설명
Runnable	void run()	매개변수 X, 반환값 X
Supplier<T>	T get()	매개변수 X, 반환값 O
Consumer<T>	void accept(T t)	매개변수 O, 반환값 X
Function<T, R>	R apply(T t)	매개변수 O, 반환값 O
Predicate<T>	boolean test(T t)	매개변수 O, 반환값 O(boolean)

public static void main(String[] args) {
    // 매개변수 X, 반환값 X
    Runnable runnable = () -> System.out.println("Runnable Test");
    runnable.run();

    // 매개변수 X, 반환값 O
    Supplier<String> supplier = () -> "Supplier Test";
    System.out.println(supplier.get());

    // 매개변수 O, 반환값 X
    Consumer<String> consumer = (something) -> System.out.println(something + "을(를) 얻었습니다.");
    consumer.accept("노트북");

    // 매개변수 O, 반환값 O
    Function<Integer, Integer> multiplyByTwo = (a) -> a * 2;
    System.out.println(multiplyByTwo.apply(5));

    // 매개변수 O, 반환값 boolean
    int avg = 80;
    Predicate<Integer> isBiggerThanAvg = (number) -> number < avg;
    System.out.println(isBiggerThanAvg.test(100));
}

// Runnable Test
// Supplier Test
// 노트북을(를) 얻었습니다.
// 10
// false

 

함수형 인터페이스	메서드	설명
BiConsumer<T, U>	void accept(T t, U u)	매개변수 2개, 반환값 X
BiPredicate<T, U>	boolean test(T t, U u)	매개변수 2개, 반환값 O (boolean)
BiFunction<T, U, R>	R apply(T t, U u)	매개변수 2개, 반환값 O

public static void main(String[] args) {
		// 매개변수 2개, 반환값 X
		BiConsumer<String, Integer> applyCompany = (company, count) -> 
			System.out.println(company + "회사에 " + count + "번 지원하였습니다.");
		applyCompany.accept("ABC", 3);
		
		// 매개변수 2개, 반환값 O (boolean)
		int maxCount = 5;
		BiPredicate<Integer, Integer> canRedo = (count, maximum) -> count < maximum;
		System.out.println(canRedo.test(3, maxCount));
		
		// 매개변수 2개, 반환값 O
		BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
		System.out.println(add.apply(3, 4));
	}
}

// ABC회사에 3번 지원하였습니다.
// true
// 7

 

함수형 인터페이스	메서드	설명
UnaryOperator<T>	T apply(T t)	매개변수의 타입 = 반환값의 타입
BinaryOperator<T>	T apply(T t, T t)	매개변수 타입 = 반환값의 타입 (매개변수는 2개이고 둘의 타입은 동일하다.)

public static void main(String[] args) {
    // 매개변수의 타입 = 반환값의 타입 
    UnaryOperator<Integer> multiplyByTwo = (a) -> a * 2;
    System.out.println(multiplyByTwo.apply(5));

    // 매개변수의 타입 = 반환값의 타입
    // 매개변수는 2개이고 둘의 타입은 동일하다.
    BinaryOperator<String> appendString = (a, b) -> a + b;
    System.out.println(appendString.apply("abc", "def"));
}

// 10
// abcdef

  컬렉션 프레임워크의 인터페이스에 추가된 다수의 디폴트 메서드들 중에 일부는 아래와 같이 함수형 인터페이스를 사용한다.

인터페이스	메서드	설명
Collection	boolean removeIf(Predicate<E> filter)	조건에 맞는 요소를 삭제
List	void replaceAll(UnaryOperator<E> operator)	모든 요소를 변환하여 대체
Iterable	void forEach(Consumer<T> action)	모든 요소에 작업 action을 수행
Map	V compute(K key, BiFunction(K, V, V> f)	지정된 키의 값에 작업 f를 수행
	V computeIfAbsent(K key, Function<K, V> f)	키가 없으면, 작업 f 수행 후 추가
	V computeIfPresent(K key, BiFunction<V, V, V> f)	지정된 키가 있을 때, 작업 f 수행
	V merge(K key, V value, BiFunction<V, V, V> f)	모든 요소에 병합작업 f를 수행
	voi forEach(BiConsumber<K, V> action)	모든 요소에 작업 action을 수행
	void replaceAll(BiFunction<K, V, V> f)	모든 요소에 치환작업 f를 수행

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("김나무 학생");
    list.add("최바다 학생");
    list.add("김과거");
    list.add("박현실");
    list.add("최미래");

    System.out.println(list);

    list.removeIf(name -> name.contains("학생"));
    System.out.println(list);

    list.replaceAll(name -> name + " 선생님");
    System.out.println(list);

    list.forEach(name -> System.out.print(name + ", "));
}
// [김나무 학생, 최바다 학생, 김과거, 박현실, 최미래]
// [김과거, 박현실, 최미래]
// [김과거 선생님, 박현실 선생님, 최미래 선생님]
// 김과거 선생님, 박현실 선생님, 최미래 선생님,

 

2. 메서드 참조(Method Reference) 🍱

  람다식을 이용하여 너무나도 간단하게 메서드를 표현할 수 있었다. 근데, 이것보다 더 간략하게 표현할 수 있을까? 메서드 참조라는 방법을 이용하여 람다식을 더 간략하게 표현해 보자. 모든 람다식에 적용 가능한 것은 아니고 람다식이 하나의 메서드만 호출하는 경우에만 사용할 수 있다.

종류	람다	메서드 참조
static 메서드 참조	(x) -> ClassName.method(x)	ClassName::method
인스턴스 메서드 참조	(obj.x) -> obj.method(x)	ClassName::method
특정 객체 인스턴스 메서드 참조	(x) -> obj.method(x)	obj::method

// static 메서드 참조
Function<String, Integer> f1 = (String s) -> Integer.parseInt(s);
Function<String, Integer> f2 = Integer::parseInt;

// 인스턴스 메서드 참조
BiFunction<String, String, Boolean> f3 = (s1, s2) -> s1.equals(s2);
BiFunction<String, String, Boolean> f4 = String::equals;

// 특정 객체 인스턴스 메서드 참조
MyClass obj = new MyClass();
Function<String, Boolean> f5 = (x) -> obj.equals(x);
Function<String, Boolean> f6 = obj::equals;

  메서드 참조를 사용하면 람다식의 일부가 생략이 된다. 하지만 컴파일러가 생략된 부분을 인터페이스와 메서드 선언부를 통해서 쉽게 알아낼 수 있기 때문에 문제가 되지 않는다.

 

  생성자를 호출하는 람다식도 메서드 참조로 변환할 수 있다.

Supplier<ClassA> s1 = () -> new ClassA();
Supplier<ClassA> s2 = ClassA::new;

Function<Integer, int[]> f1 = x -> new int[x];
Function<Integer, int[]> f2 = int[]::new;

---

  람다식과 메서드 참조를 알긴 해도 익숙하지 않으면 잘 사용하지 못하는 거 같다. 같이 연습해서 얼른 익숙해지도록 하자.

 

 

해당 글은 남궁 성님의 Java의 정석을 읽고 작성한 것입니다.