Java의 기본 함수형 인터페이스

서론

사내 코드를 살펴보다가 함수형 인터페이스, 그중에서도 BiFunction<T, U, R>을 사용한 로직을 자주 볼 수 있었는데, 실제로 보니 생소하기도 하고, 저도 로직에 한번 녹여보고 싶어서 이번 기회에 정리를 해보려고 합니다.
 

함수형 인터페이스 종류

Java의 함수형 인터페이스는 JAVA 8부터 도입된 기능으로, 하나의 추상 메서드만 가지는 인터페이스를 의미합니다. 이러한 인터페이스들은 람다 표현식이나 메서드 참조를 통해 간단하게 표현할 수 있으며, Java에서는 java.util.function 패키지를 통해 미리 정의된 다양한 함수형 인터페이스를 제공합니다.
Java에서 미리 정의해 둔 주요 함수형 인터페이스는 다음과 같습니다.

1. Function<T, R>: 입력 인수 T를 받아 결과 R을 반환하는 함수를 나타낸다. 주로 데이터 변환 작업에 사용된다.
   
   • R apply(T t)
2. BiFunction<T, U, R>: 두 개의 입력 인수 T와 U를 받아 결과 R을 반환하는 함수를 나타낸다.
   • R apply(T t, U u)
3. Consumer<T>: 입력 인수 T를 받아 처리하는 함수를 나타낸다. 반환값은 없으며, 주로 데이터를 소비하는 작업에 사용된다.
   • void accept(T t)
4. BiConsumer<T, U>: 두 개의 입력 인수 T와 U를 받아 처리하는 함수를 나타낸다. 반환 값은 없다.
   • void accept(T t, U u)
5. Supplier<T>: 입력 인수 없이 결과 T를 반환하는 함수를 나타낸다. 주로 값을 생성하거나 공급하는 작업에 사용된다.
   • T get()
6. Predicate<T>: 입력 인수 T를 받아 boolean 값을 반환하는 함수를 나타낸다. 주로 조건 검사에 사용된다.
   • boolean test(T t)
7. BiPredicate<T, U>: 두 개의 입력 인수 T와 U를 받아 boolean 값을 반환하는 함수를 나타낸다.
   • boolean test(T t, U u)
8. UnaryOperator<T>: 입력 인수 T를 받아 동일한 유형의 결과를 반환하는 함수를 나타낸다. Function<T, T>의 서브 인터페이스이며, 주로 단항 연산 작업에 사용된다.
   • T apply(T t)
9. BinaryOperator<T>: 두 개의 입력 인수 T를 받아 동일한 유형의 결과를 반환하는 함수를 나타낸다. BiFunction<T, T, T>의 서브 인터페이스이며, 주로 이항 연산 작업에 사용된다.
   • T apply(T t1, T t2)
10. 이 외의 함수들

 

예제

⭐️ Function<T, R> : 입력 인수 T를 받아 결과 R을 반환하는 함수, 주로 데이터 변환 작업에 사용

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> strLength = str -> str.length();

        System.out.println("Length of 'Hello': " + strLength.apply("Hello")); // 출력: Length of 'Hello': 5
    }
}

 

⭐️ BiFunction<T, U, R>: 두 개의 입력 인수 T와 U를 받아 결과 R을 반환하는 함수

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;

        System.out.println("10 + 20 = " + add.apply(10, 20)); // 출력: 10 + 20 = 30
    }
}

 

⭐️ Consumer<T>: 입력 인수 T를 받아 처리하는 함수, 반환값은 없으며, 주로 데이터를 소비하는 작업에 사용

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<String> printUpperCase = str -> System.out.println(str.toUpperCase());

        printUpperCase.accept("hello world"); // 출력: HELLO WORLD
    }
}

 

⭐️ BiConsumer<T, U>: 두 개의 입력 인수 T와 U를 받아 처리하는 함수, 반환 값은 없음

import java.util.function.BiConsumer;

public class Main {
    public static void main(String[] args) {
        BiConsumer<String, Integer> printNTimes = (str, n) -> {
            for (int i = 0; i < n; i++) {
                System.out.println(str);
            }
        };

        printNTimes.accept("Hello", 3);
        // 출력:
        // Hello
        // Hello
        // Hello
    }
}

 

⭐️ Supplier<T>: 입력 인수 없이 결과 T를 반환하는 함수, 주로 값을 생성하거나 공급하는 작업에 사용

import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<Double> randomSupplier = () -> Math.random();

        System.out.println("Random number: " + randomSupplier.get()); // 출력: Random number: 0.123456789 (예시)
    }
}

 

⭐️ Predicate<T>: 입력 인수 T를 받아 boolean 값을 반환하는 함수, 주로 조건 검사에 사용

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<Integer> isEven = num -> num % 2 == 0;

        System.out.println("10은 짝수입니까? " + isEven.test(10)); // 출력: 10은 짝수입니까? true
        System.out.println("15은 짝수입니까? " + isEven.test(15)); // 출력: 15은 짝수입니까? false
    }
}

 

⭐️ BiPredicate<T, U>: 두 개의 입력 인수 T와 U를 받아 boolean 값을 반환하는 함수

import java.util.function.BiPredicate;

public class Main {
    public static void main(String[] args) {
        BiPredicate<Integer, Integer> areBothEven = (a, b) -> a % 2 == 0 && b % 2 == 0;

        System.out.println("10과 20은 모두 짝수인가? " + areBothEven.test(10, 20)); // 출력: 10과 20은 모두 짝수인가? true
        System.out.println("10과 15은 모두 짝수인가? " + areBothEven.test(10, 15)); // 출력: 10과 15은 모두 짝수인가? false
    }
}

 

⭐️ UnaryOperator<T>: 입력 인수 T를 받아 동일한 유형의 결과를 반환하는 함수, 주로 단항 연산 작업에 사용

import java.util.function.UnaryOperator;

public class Main {
    public static void main(String[] args) {
        UnaryOperator<Integer> square = num -> num * num;

        System.out.println("5의 제곱: " + square.apply(5)); // 출력: 5의 제곱: 25
    }
}

 

⭐️ BinaryOperator<T>: 두 개의 입력 인수 T를 받아 동일한 유형의 결과를 반환하는 함수, 주로 이항 연산 작업에 사용

import java.util.function.BinaryOperator;

public class Main {
    public static void main(String[] args) {
        BinaryOperator<Integer> multiply = (a, b) -> a * b;

        System.out.println("5 * 10 = " + multiply.apply(5, 10)); // 출력: 5 * 10 = 50
    }
}

 

 

함수형 인터페이스의 장점

• 간결한 코드: 람다 표현식을 사용하면 코드를 더 간결하게 작성할 수 있으며, 이는 코드의 가독성과 유지 보수성을 높인다.
• 높은 모듈성: 함수형 프로그래밍은 순수 함수와 높은 모듈성을 지향한다. 이를 통해 코드를 재사용하기 쉬워지며, 테스트와 디버깅이 용이해진다.
• 불변성: 함수형 프로그래밍은 상태 변경을 최소화하며 불변 데이터 구조를 사용한다. 이로 인해 안전성이 높아지며, 버그 발생 가능성이 줄어든다.
• 고차 함수 사용: 고차 함수는 함수를 인자로 받거나 함수를 반환하는 함수이기에, 고차함수를 사용하여 함수를 조합하거나 추상화하여 강력한 기능을 구현할 수 있다.
• 자연스러운 병렬 처리: 함수형 프로그래밍은 부수 효과(Side Effect)가 없는 순수 함수를 선호하므로, 동시성과 병렬 처리에 적합하다. 이를 통해 멀티코어 시스템에서 성능 향상을 얻을 수 있다.
• 지연 평가: 함수형 프로그래밍에서는 지연 평가(Lazy Evaluation)를 사용할 수 있다. 이를 통해 불필요한 계산을 피하고, 성능을 향상시킬 수 있다.
• 컬렉션 처리의 효율성: 함수형 프로그래밍은 컬렉션 처리에 대한 강력한 도구를 제공한다. 스트림 API를 사용하면 컬렉션을 쉽게 조작하고 반환할 수 있다.

 

 

번외

추가로 제가 알고싶었던 BiFunction에 대해서 더 자세히 정리하겠습니다.
먼저 BiFunction 인터페이스의 정의는 다음과 같습니다.

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

여기서 T, U, R은  제네릭 타입이며, 각각 두 개의 입력 인자와 반환 값에 해당하는 타입을 나타냅니다.
BiFunction 인터페이스에는 다음 메서드들이 포함되어 있습니다.

1. apply(T t, U u): 두 개의 인자를 받아서 결과를 반환한다. 이 메서드를 구현하여 실제 작업을 수행하는 데 사용된다.
2. andThen(Function<? super R, ? extents V> after): 이 메서드는 현재의 BiFunction 인스턴스와 다른 Function 인스턴스를 연결하며, 현재 인스턴스의 결과를 다른 함수의 입력으로 사용한다. 따라서 최종적으로 새로운 BiFunction 인스턴스를 반환한다.

예제는 다음과 같습니다.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        // BiFunction 인스턴스 생성
        BiFunction<Integer, Integer, Integer> adder = (a, b) -> a + b;

        // apply 메소드를 사용하여 두 숫자를 더함
        int result = adder.apply(5, 3);
        System.out.println("5 + 3 = " + result);

        // andThen 메소드를 사용하여 두 함수를 연결
        BiFunction<Integer, Integer, Integer> multiplier = (a, b) -> a * b;
        Function<Integer, String> toString = num -> "결과: " + num;

        BiFunction<Integer, Integer, String> combined = adder.andThen(toString);
        String combinedResult = combined.apply(5, 3);
        System.out.println(combinedResult);
    }
}

출력 결과
5 + 3 = 8
결과: 8

위 코드는 두 개의 BiFunction 인스턴스를 생성하고, apply 메서드를 사용하여 두 숫자를 더한 다음, andThen 메서드를 사용하여 결과를 문자열로 변환하는 함수와 연결합니다.

import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        // 문자열 결합 BiFunction 인스턴스 생성
        BiFunction<String, String, String> concat = (a, b) -> a + b;

        // apply 메소드를 사용하여 두 문자열을 결합
        String result = concat.apply("Hello, ", "World!");
        System.out.println("결과: " + result);

        // andThen 메소드를 사용하여 대문자 변환 함수를 연결
        Function<String, String> toUpperCase = String::toUpperCase;
        BiFunction<String, String, String> combined = concat.andThen(toUpperCase);

        // 연결된 함수를 사용하여 문자열 결합 및 대문자 변환 수행
        String combinedResult = combined.apply("hello, ", "world!");
        System.out.println(combinedResult);
    }
}

출력 결과
결과: Hello, World!
HELLO, WORLD!

위 코드는 문자열 결합을 수행하는 BiFunction 인스턴스를 생성한 다음, apply 메서드를 사용하여 두 문자열을 결합합니다. 그런 다음 andThen 메서드를 사용하여 대문자 변환 함수를 연결하고, 연결된 함수를 사용하여 문자열 결합과 대문자 변환을 동시에 수행합니다.

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        // Map 생성 및 데이터 삽입
        Map<String, Integer> map = new HashMap<>();
        map.put("A", 10);
        map.put("B", 20);
        map.put("C", 30);

        // BiFunction 인스턴스 생성
        BiFunction<Map<String, Integer>, String[], Integer> sumValues = (m, keys) -> {
            int sum = 0;
            for (String key : keys) {
                sum += m.getOrDefault(key, 0);
            }
            return sum;
        };

        // 두 키에 대한 값의 합계를 반환
        String[] keys = {"A", "B"};
        int result = sumValues.apply(map, keys);
        System.out.println("키 A와 키 B의 값의 합계: " + result);
    }
}

출력 결과
키 A와 키 B의 값의 합계: 30

위 코드는 Map에 데이터를 삽입한 후, 두 키에 대한 값의 합계를 반환하는 BiFunction 인스턴스를 생성합니다. apply 메서드를 사용하여 Map과 키 배열을 전달하면, 함수는 키 배열에 해당하는 값들의 합계를 반환합니다.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        // 두 개의 리스트 생성
        List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3));
        List<Integer> list2 = new ArrayList<>(Arrays.asList(4, 5, 6));

        // BiFunction 인스턴스 생성
        BiFunction<List<Integer>, List<Integer>, List<Integer>> addLists = (l1, l2) -> {
            List<Integer> result = new ArrayList<>();
            int size = Math.min(l1.size(), l2.size());
            for (int i = 0; i < size; i++) {
                result.add(l1.get(i) + l2.get(i));
            }
            return result;
        };

        // 두 리스트에서 동일한 인덱스의 요소들을 더함
        List<Integer> sumList = addLists.apply(list1, list2);
        System.out.println("두 리스트의 요소별 합계: " + sumList);
    }
}

출력 결과
두 리스트의 요소별 합계: [5, 7, 9]

위 코드는 두 개의 정수 리스트를 생성한 후, 동일한 인덱스의 요소들을 더하는 BiFunction 인스턴스를 생성합니다. apply 메서드를 사용하여 두 리스트를 전달하면, 함수는 각 인덱스별 합계를 가진 새로운 리스트를 반환합니다.
또한 Java에서 제공하는 다른 함수형 인터페이스와 조합하여 더 복잡한 작업을 수행할 수 있습니다. 예를 들어, BiFunction과 Function 인터페이스를 함께 사용하여 다양한 입력 및 출력 유형을 처리하는 특정 작업을 처리할 수 있습니다.

import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        // BiFunction 인스턴스 생성
        BiFunction<String, Integer, String> repeat = (str, count) -> {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < count; i++) {
                sb.append(str);
            }
            return sb.toString();
        };

        // Function 인스턴스 생성
        Function<String, Integer> countVowels = str -> {
            int count = 0;
            String vowels = "AEIOUaeiou";
            for (char c : str.toCharArray()) {
                if (vowels.indexOf(c) != -1) {
                    count++;
                }
            }
            return count;
        };

        // 문자열 반복 및 모음 개수 계산
        String repeatedStr = repeat.apply("Hello", 3);
        int vowelCount = countVowels.apply(repeatedStr);

        System.out.println("반복된 문자열: " + repeatedStr);
        System.out.println("모음 개수: " + vowelCount);
    }
}

출력 결과
반복된 문자열: HelloHelloHello
모음 개수: 6

위 코드에서는 repeat라는 BiFunction 인스턴스를 생성하여 문자열을 주어진 횟수만큼 반복하고, countVowels라는 Function 인스턴스를 생성하여 문자열에서 모음 개수를 계산합니다. 그 후, 두 함수형 인스턴스를 생성하여 문자열에서 모음 개수를 계산합니다. 따라서 최종적으로 두 함수형 인터페이스를 함께 사용하여 문자열을 반복한 후 모음 개수를 계산할 수 있습니다.
이처럼 BiFunction을 다른 함수형 인터페이스와 함께 사용하여 작업을 조합하고, 코드의 가독성과 유연성을 향상시킬 수 있습니다. 이러한 방식으로 함수형 프로그래밍 패러다임의 이점을 적극 활용하여 코드의 재사용성, 테스트 용이성, 유지 관리성을 높일 수 있기에 잘 숙지해서 사용했으면 좋겠습니다.