TIL - 2024/09/09

Exception

 

예외 처리는 정말 중요하다.

 

예외란?

 

예외(Exception)는 프로그램 실행 중 발생할 수 있는 예기치 못한 상황을 의미

예외 처리는 프로그램의 안정성을 높이고 오류를 우아하게 처리하는 데 필수적

 

예외에도 종류가 있다

 

Error와 Exception

 

Error는 개발자가 직접 처리할 수 "없는" 오류

ex) OutOfMemoryError, StackOverflowError

 

Exception은 개발자가 직접 처리할 수 "있는" 오류

1. Checked Exception : 컴파일 시에 예외 처리를 강제하는 예외

ex) IOException, SQLException

2. Unchecked Exception : 런타임 시에 발생하는 예외

ex) NullPointerException, ArrayIndexOutOfBoundsException

 

 

try-catch

try {
    // 예외 발생 가능성 있는 코드
} catch (ExceptionType e) {
    // 예외 처리 코드
}

 

finally

try {
    // 예외 발생 가능성 있는 코드
} catch (ExceptionType e) {
    // 예외 처리 코드
} finally {
    // 항상 실행되는 코드
}

 

사용자 정의 예외

class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

결론(정리)

• Checked Exception은 반드시 try-catch 블록으로 처리하거나, 메소드 시그니처에 throws로 선언하여 호출자에게 예외 처리를 위임해야 한다. 예외가 발생할 가능성이 높은 상황에서 프로그램의 안정성을 확보하기 위해서,
• Unchecked Exception은 try-catch 블록으로 처리하지 않아도 된다. 주로 프로그래밍 오류로 인해 발생하며, 코드 수정으로 예방할 수 있다. 필요시 전역 예외 처리기를 사용하여 관리 가능

 

Stream

 

자바 8에서 도입된 기능으로, 데이터를 처리하는 방식을 선언적이고 함수형 프로그래밍 스타일로 변경해 준다.

스트림은 배열이나 컬렉션 같은 데이터를 반복문 없이도 필터링, 변환, 집계할 수 있도록 도와준다.

기존에는 루프를 사용해 데이터를 직접 순회하며 조작했지만,

스트림을 통해서는 이러한 작업을 더 간결하고 직관적으로 처리 가능

 

스트림이란?

 

스트림은 데이터의 흐름을 추상화한 것으로, 데이터를 필터링하고 변환하며 집계하는 작업을 일련의 함수적 조합으로 수행할 수 있다.  중요한 점은 스트림은 원본 데이터를 변경하지 않으며, 데이터를 일련의 처리 단계를 통해 가공한다.

 

 

• 데이터 처리 흐름: 스트림은 데이터 소스(컬렉션, 배열 등)에서 시작해 다양한 중간 작업을 거쳐 최종 작업에서 결과를 생성
• 데이터를 변화시키지 않음: 스트림 자체는 데이터를 변경하지 않고, 모든 처리는 새로운 스트림 또는 결과로 이어짐

 

스트림의 주요 작업 흐름:

• 스트림 생성: 데이터 소스로부터 스트림을 생성
• 중간 연산: 데이터를 필터링하고 변환하는 작업을 수행, 이때 지연 연산으로 동작하며, 최종 연산이 호출되기 전까지는 실제 연산이 실행되지 않는다.
• 최종 연산: 결과를 얻거나 스트림을 소모하는 작업

스트림의 특징

1. 지연 연산(Lazy Evaluation): 스트림에서 중간 연산은 최종 연산이 호출되기 전까지 실행되지 않는다. 즉, 중간 작업에서 필요한 연산을 정의하지만, 실제 처리는 최종 연산이 실행될 때 수행됨. 이로 인해 성능 최적화가 가능함
2. 병렬 처리(Parallel Processing): 스트림은 내부적으로 병렬 처리를 지원함. parallelStream()을 사용하면 데이터를 여러 스레드에서 병렬로 처리할 수 있어, 대용량 데이터 처리에 유용
3. 불변성(Immutability): 스트림을 통해 데이터를 처리할 때 원본 데이터는 변경되지 않는다. 모든 연산은 새로운 스트림을 생성하며, 원본 데이터에 영향을 미치지 않음

 

스트림 생성

스트림은 여러 가지 방법으로 생성할 수 있습니다. 대표적인 방법은 컬렉션(Collection)에서 스트림을 생성하는 것

List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream();

 

중간 연산 (Intermediate Operations)

중간 연산은 스트림을 변환하거나 필터링하는 데 사용,

중간 연산은 또 다른 스트림을 반환하며, 연산은 지연되어 최종 연산이 호출될 때 수행

Stream<T> filter(Predicate<? super T> predicate);

List<String> filteredList = list.stream()
                                .filter(s -> s.startsWith("a"))
                                .collect(Collectors.toList());

 

맵핑 (Mapping)

맵(map)은 스트림 내 요소들을 하나씩 특정 값으로 변환해줍니다. 이 때 값을 변환하기 위한 람다를 인자로 받음

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

List<String> mappedList = list.stream()
                              .map(String::toUpperCase)
                              .collect(Collectors.toList());

 

최종 연산 (Terminal Operations)

최종 연산은 스트림을 소모하며, 최종 결과를 생성함 대표적인 최종 연산에는 forEach, collect, reduce 등

list.stream()
    .forEach(System.out::println);
    //forEach

List<String> collectedList = list.stream()
                                 .collect(Collectors.toList());
                                 //collect
                                 
 Optional<String> reduced = list.stream()
                               .reduce((s1, s2) -> s1 + s2);
                               //reduce

 

 

예시 설명

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class LazyEvaluationExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "melon");

        Stream<String> stream = list.stream()
                                    .filter(s -> {
                                        System.out.println("filtering: " + s);
                                        return s.startsWith("a");
                                    })
                                    .map(s -> {
                                        System.out.println("mapping: " + s);
                                        return s.toUpperCase();
                                    });

        System.out.println("스트림이 정의되었지만 아직 처리되지 않았습니다.");

        // 최종 연산을 통해 스트림 처리 시작
        List<String> result = stream.collect(Collectors.toList());

        System.out.println("결과: " + result);
    }
}

 

실행 결과 

 

스트림이 정의되었지만 아직 처리되지 않았습니다.
filtering: apple
mapping: apple
filtering: banana
filtering: orange
filtering: grape
filtering: melon
결과: [APPLE]

 

 

이 코드를 보면 지연 연산에 대해 설명하는 예시다
중간 연산은 실행되지 않고, 최종 연산이 호출될 때까지 연산을 지연시킨다.
중간 연산인 filter , map이 정의만 되었고, 최종 연산인 collect가 호출될 때 실행된다.
불필요한 연산을 피하고 성능 최적화하기에 좋다.