Java - 람다, 스트림, Optional

📚 람다 (Lambda)

함수(메서드)를 좀 더 간단하고 편리하게 표현하기 위해 고안된 문법 요소

// sum 메서드 람다식
(num1, num2) -> num1 + num2

// 람다식을 객체로 표현
new Object() { // 익명 클래스
    int sum(int num1, int num2) {
        return num1 + num2;
    }
}

람다식은 사실 위와 같이 익명 클래스다.

익명 클래스: 객체의 선언과 생성을 동시에 하여 오직 하나의 객체를 생성하고 단 한 번만 사용되는 일회용 클래스

 

📘 함수형 인터페이스

public class LamdaExample1 {
    public static void main(String[] args) {
        Func func = (num1, num2) -> num1 + num2
        System.out.println(func.sum(10, 15))
}

@FunctionalInterface // 컴파일러가 인터페이스가 바르게 정의되었는 지 확인할 수 있도록
interface Func {
    public abstract int sum(int num1, int num2);
}

// 출력값
25

함수형 인터페이스를 활용해 람다식을 다룰 수 있다.

 

인터페이스 문법으로 람다식을 다루는 것이 가능한 이유

• 람다식도 결국 객체이기 때문에 인터페이스에 정의된 추상 메서드를 구현할 수 있다.

함수형 인터페이스가 단 하나의 추상 메서드만 가질 수 있는 이유

• 람다식과 인터페이스의 메서드가 1:1로 매칭 되어야 한다.

@FunctionalInterface
public interface Func {
    public int accept(int x, int y);
}

public class MyFunctionalInterfaceExample {
    public static void main(String[] args) throws Exception {
        Func example;
        example = (x, y) -> { // 1
            int result = x + y;
            return result;
        };
        example = (x, y) -> { return x + y; }; // 2
        example = (x, y) ->  x + y; // 3
        example = (x, y) -> sum(x, y); // 4
        example = (x, y) -> sum;
        example = Integer::sum; // 5, 메서드 레퍼런스
        
        // 1, 2, 3, 4, 5 모두 같은 동작을 한다.
 
    }

    public static int sum(int x, int y){
        return x + y;
    }
}

 

📄 Java에서 기본적으로 제공하는 함수형 인터페이스

Functional Interface	Descripter	Method
Runnable	() -> void	void run()
Callable<V>	() -> V	V call()
Supplier<T>	() -> T	T get()
Consumer<T>	T -> void	void accept(T t)
Function<T, R>	T -> R	R apply(T t)
Predicate<T>	T -> boolean	boolean test(T t)
Comparator<T>	(T, T) -> int	int compare(T o1, T o2)

함수형 인터페이스 API DOC

 

📘 메서드 레퍼런스

클래스::메서드 // 정적 메서드 참조
참조 변수::메서드 // 인스턴스 메서드 참조

(left, right) -> Math.max(left, right);
(left, right) -> Math::max; // 정적 메서드 참조

(a, b) -> { return new 클래스(a, b); };
(a, b) -> 클래스::new; // 생성자 참조 문법

 

📚 스트림

• 배열, 컬렉션의 저장 요소를 하나씩 참조해서 람다식으로 처리할 수 있도록 해주는 반복자
• 데이터를 연속적으로 전달하는 통로

 

📘 특징

📄 선언형으로 데이터 소스를 처리한다.

선언형 프로그래밍: "어떻게" 수행하는지 보다 "무엇을" 수행하는지에 관심을 두는 프로그래밍 패러다임

public class Example {
    public static void main(String[] args){
        // List에 있는 숫자들 중에서 4보다 큰 짝수의 합계 구하기
        List<Integer> numbers = List.of(1, 3, 6, 7, 8, 11);
        int sum = 0;

        // 명령형 (Imperative) 프로그래밍
        for(int number : numbers){
            if(number > 4 && (number % 2 == 0)){
                sum += number;
            }
        }
        
        // 선언형 (Declarative) 프로그래밍
        int sum = numbers.stream()
            .filter(number -> number > 4 && (number % 2 == 0))
            .mapToInt(number -> number)
            .sum();
    }
}

 

📄 람다식으로 요소 처리 코드를 제공한다.

stream.forEach(s -> {
    String name = s.getName();
    int score = s.getScore();
    System.out.println(name + " - " + score);
});

 

📄 내부 반복자를 사용하므로 병렬 처리가 쉽다.

외부 반복자(external iterator)

• 개발자가 직접 컬렉션의 요소를 반복해서 가져오는 코드 패턴
• 예) index를 사용하는 for문, iterator를 사용하는 while문

내부 반복자(internal iterator)

• 컬렉션 내부에서 요소들을 반복시키고 개발자는 요소당 처리해야 할 코드만 제공하는 코드 패턴

내부 반복자의 이점

• 어떻게 요소를 반복시킬 것인가는 컬렉션에 맡겨두고, 개발자는 요소 처리 코드에만 집중할 수 있다
• 요소들의 반복 순서를 변경하거나 멀티 코어 CPU를 최대한 활용하기 위해 요소들을 분배시켜 병렬 작업을 할 수 있게 도와주기 때문에 하나씩 처리하는 순차적 외부 반복자보다 효율적으로 요소를 반복시킬 수 있다.

병렬 스트림을 사용하기 위해서는 parallel 메서드를 사용하면 된다.

 

📄 중간 연산과 최종 연산을 할 수 있다.

중간 연산: 매핑, 필터링, 정렬 등을 수행할 수 있다.

최종 연산: 반복, 카운팅, 평균, 총합 등의 집계를 수행할 수 있다.

 

📘 파이프라인 구성

컬렉션의 요소를 리덕션의 결과물로 바로 집계할 수 없을 때 필터, 매핑, 정렬, 그룹화 등의 중간 연산이 필요하다.

리덕션(Reduction): 대량의 데이터를 가공해서 축소하는 것
리덕션의 결과물: 데이터의 합계, 평균값, 카운팅, 최댓값, 최솟값 등

📄 파이프라인

• 여러개의 스트림이 연결되어 있는 구조
• 파이프라인에서 최종 연산을 제외하고는 모두 중간 연산 스트림이다.

중간 스트림이 생성될 때 요소들이 바로 중간 연산되는 것이 아니라 최종 연산이 시작되기 전까지는 지연된다. 최종 연산이 시작되면 비로소 컬렉션의 요소가 하나씩 중간 스트림에서 연산되고 최종 연산까지 오게 된다.

 

📘 스트림 생성

// List로부터 스트림을 생성
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> listStream = list.stream();

// 배열로부터 스트림을 생성
Stream<String> stream = Stream.of("a", "b", "c"); //가변인자
Stream<String> stream = Stream.of(new String[] {"a", "b", "c"});
Stream<String> stream = Arrays.stream(new String[] {"a", "b", "c"});
Stream<String> stream = Arrays.stream(new String[] {"a", "b", "c"}, 0, 3); //end 범위 미포함

// 4이상 10미만의 숫자를 갖는 IntStream
IntStream stream = IntStream.range(4, 10);

리턴 타입	메서드(매개 변수)	소스
Stream	java.util.Collection.Stream(), java.util.Collection.parallelStream( )	컬렉션
Stream, IntStream, LongStream, DoubleStream	Arrays.stream(T[]), Arrays.stream(int[]), Arrays.stream(long[]), Arrays.stream(double[]), Stream.of(T[]), IntStream.of(int[]) LongStream.of(long[]), DoubleStream.of(double[])	배열
IntStream	IntStream.range(int, int), IntStream.rangeClosed(int, int)	int 범위
LongStream	LongStream.range(long, long), LongStream.rangeClosed(long, long)	long 범위

주의할 점

• 스트림은 데이터 소스로부터 읽기만 할 뿐 변경하지 않는다. (Read-only)
• 스트림은 일회용이다.

 

📘 중간 연산

📄 필터링 (filter(), distinct())

filter(): 조건에 맞는 데이터만을 정제한다.

distinct(): 중복을 제거한다.

 

📄 매핑 (map())

map(): 기존의 Stream 요소들을 대체하는 요소로 구성된 새로운 Stream을 형성한다.

flatMap(): 요소를 대체하는 복수 개의 요소들로 구성된 새로운 Stream을 형성한다.

map 메서드와 flatMap 메서드의 차이

mapToInt, mapToLong, mapToDouble, mapToObject

 

📄 정렬 (sorted())

list.stream()
    .sorted() // 오름차순 정렬
    .forEach(n -> System.out.println(n));

list.stream()
    .sorted(Comparator.reverseOrder()) // 내림차순 정렬
    .forEach(n -> System.out.println(n));

workersStream
    .sorted(Comparator.comparing(Employee::getId))
    .forEach(System.out::println);

 

📄 연산 결과 확인 (peek())

주로 연산 결과를 확인하여 디버깅하고자 할 때 사용한다.

intStream
    .filter(a -> a % 2 == 0)
    .peek(n -> System.out.println(n))
    .sum();

 

📘 최종 연산

📄 연산 결과 확인 (foreach())

요소를 하나씩 연산한다.

intStream
    .filter(a -> a % 2 == 0)
    .forEach(n -> System.out.println(n));

 

📄 매칭 (match())

특정한 조건을 충족하는지 검사한다.

allMatch(): 모든 요소들이 매개값으로 주어진 Predicate의 조건을 만족하는지 조사

anyMatch(): 최소한 한 개의 요소가 매개값으로 주어진 Predicate의 조건을 만족하는지 조사

noneMatch(): 모든 요소들이 매개값으로 주어진 Predicate의 조건을 만족하지 않는지 조사

int[] intArr = {2, 4, 6};
boolean result = Arrays.stream(intArr).allMatch(a -> a % 2 == 0);
System.out.println("모두 2의 배수인가? " + result);

result = Arrays.stream(intArr).anyMatch(a -> a % 3 == 0);
System.out.println("하나라도 3의 배수가 있는가? " + result);

result = Arrays.stream(intArr).noneMatch(a -> a % 3 == 0);
System.out.println("3의 배수가 없는가? " + result);

출력값

모두 2의 배수인가? true
하나라도 3의 배수가 있는가? true
3의 배수가 없는가? false

 

📄 기본 집계 (sum(), count(), average(), max(), min())

sum(): 총합, count(): 개수, average(): 평균, max(): 최댓값, min(): 최솟값

 

📄 reduce()

reduce는 누적하여 하나로 응축(reduce)하는 방식으로 동작한다.

int[] intArr = {1, 2, 3, 4, 5};

long sum = Arrays.stream(intArr).sum();
System.out.println("intArr의 전체 요소 합 " + sum);

int sum1 = Arrays.stream(intArr)
    .map(el -> el * 2)
    .reduce((a, b) -> a + b)
    .getAsInt();
System.out.println("초기값 없는 reduce " + sum1);

int sum2= Arrays.stream(intArr)
    .map(el -> el * 2)
    .reduce(0, (a, b) -> a + b);
System.out.println("초기값 존재하는 reduce " + sum2)

출력값

intArr의 전체 요소 합 15
초기값 없는 reduce 30
초기값 존재하는 reduce 30

 

📄 collect()

Stream의 요소들을 List, Set, Map 등 다른 종류의 결과로 수집하고 싶은 경우 사용한다.

List<Student> maleList = totalList.stream()
    .filter(s -> s.getGender() == Student.Gender.Male)
    .collect(Collectors.toList());

Set<Student> femaleSet = totalList.stream()
    .filter(s -> s.getGender() == Student.Gender.Female)
    .collect(Collectors.toCollection(HashSet::new));

 

📘 Optional

NullPointerException(NPE), 즉 null 값으로 인해 에러가 발생하는 현상을 객체 차원에서 효율적으로 방지하고자 도입되었다.

Optional 클래스는 모든 타입의 객체를 담을 수 있는 래퍼(Wrapper) 클래스다.

 

객체 생성 of() 또는 ofNullable()을 사용한다. 참조 변수가 null일 가능성이 있으면 ofNullable()을 사용한다.

Optional<String> opt1 = Optional.of("123");
Optional<String> opt2 = Optional.ofNullable(null);

Optional<String> opt3 = Optional.<String>empty(); // 기본값으로 초기화
Optional<String> opt4 = Optional.empty(); // 기본값으로 초기화

System.out.println(opt1.orElse("else")); // "123"
System.out.println(opt2.orElse("else")); // "else"

List<String> languages = Arrays.asList(
    "Ruby", "Python", "Java", "Go", "Kotlin");
Optional<List<String>> listOptional = Optional.of(languages);

int size = listOptional
    .map(List::size)
    .orElse(0); // 5

스트림과 유사하게 메서드 체이닝이 가능하다.

 

Java Optional Docs