iterator_stream

Iterator

Iterator는 컬렉션의 데이터를 순회하고 접근하기 위한 인터페이스로, 컬렉션 구현체의 내부 구조를 알지 못해도, 일관된 방식으로 요소에 접근할 수 있게 해준다.

Iterator 인터페이스의 주요 메서드

Iterator 인터페이스는 다음과 같은 메서드를 가지고 있다.

boolean hasNext(): 다음 요소가 존재하는지 확인하는 메서드로, 다음 요소가 있으면 true를 반환하고, 더 이상 순회할 요소가 없으면 false를 반환
E next(): 다음 요소를 반환(호출할 다음 요소가 없을 경우 NoSuchElementException 예외가 발생)

public class IteratorExample {

    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        // Iterator 생성
        Iterator<String> iterator = names.iterator();

        // 순회하면서 출력
        while (iterator.hasNext()) {
            String name = iterator.next();
            System.out.println(name);
        }
    }
}

스트림

자바 8부터 도입된 Stream은 데이터 소스를 추상화하고, 데이터를 처리하는 데 유용한 메서드들을 정의한 인터페이스다.

Iterator vs Stream

Iterator가 데이터를 어떻게 처리할지 명시하는 명령형imperative 방식이라면, Stream은 무엇을 할지만 선언하는 선언형 방식이다.

컬렉션 요소를 람다식을 활용하여 처리 가능하며, Iterator보다 많은 연산을 지원
데이터 소스(배열, 컬렉션 등)가 무엇이든 동일한 방식으로 데이터를 처리하여 코드의 재사용성 향상

public static void main(String[] args) {
    String[] array = {"a", "b", "c", "d", "e"};
    List<String> list = Arrays.asList(array);

    // 스트림 생성
    Stream<String> arrayStream = Arrays.stream(array);
    Stream<String> listStream = list.stream();

    // 두 스트림의 소스는 다르지만, 동일한 방식으로 처리
    arrayStream.sorted().forEach(System.out::println);
    listStream.sorted().forEach(System.out::println);
}

스트림의 특징

1. 데이터 소스 불변

스트림은 데이터 소스를 변경하지 않고, 연산 결과로 새로운 스트림을 반환하거나 최종 결과를 생성한다.

public static void main(String[] args) {
    List<String> list = Arrays.asList("a", "c", "d", "b", "e");
    // list.stream().sorted()는 list 원본을 정렬하지 않음
    List<String> sortedList = list
            .stream()
            .sorted()
            .collect(Collectors.toList()); // 정렬된 새 리스트가 생성
}

2. 내부 반복

스트림을 사용하면 반복문을 메서드 호출을 통해 요소를 처리할 수 있다.

class Example {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c", "d", "e");

        // 외부 반복
        for (String string : list) {
            System.out.println(string);
        }

        // 내부 반복
        list.stream().forEach(System.out::println);
    }
}

3. 중간 연산과 최종 연산

스트림의 연산은 파이프라인(pipeline)을 구성하며, 두 가지 유형으로 나뉜다.

중간 연산: 스트림을 반환하는 연산으로, 스트림에 연속해서 여러 개의 중간 연산을 호출 가능
최종 연산: 스트림을 반환하지 않는 연산으로, 스트림에 최종 연산을 호출하면 스트림이 소모
- 소모하게 되면, 더 이상 스트림을 사용할 수 없음

public static void main(String[] args) {
    List<String> list = Arrays.asList("a", "b", "c", "d", "e");

    Stream<String> stream = list.stream();
    stream.sorted(); // 중간 연산
    stream.forEach(System.out::println); // 최종 연산
}

4. 지연 연산

스트림의 중간 연산은 최종 연산이 호출되기 전까지는 실제로 수행되지 않고, 최종 연산이 호출되면 파이프라인이 동작하기 시작한다.

스트림 생성

대부분의 데이터 소스는 스트림으로 변환할 수 있다.

Collection 인터페이스: stream() 메서드가 정의되어 있어 컬렉션을 스트림으로 변환(자손 클래스 모두 사용 가능)
Arrays 클래스: 배열을 스트림으로 변환하는 stream() 메서드가 정의되어 있어 배열을 스트림으로 변환
Map 인터페이스: keySet(), values(), entrySet() 메서드를 사용하여 스트림으로 변환
Stream 클래스(static 메서드)
- Stream.of(1, 2, 3)
- Stream.empty()
- Stream.concat(stream1, stream2)
무한 스트림
- Stream.iterate(1, n -> n + 2)
- Stream.generate(Math::random)
기본형 스트림
- IntStream.range(1, 10)
- IntStream.rangeClosed(1, 10)

스트림의 중간 연산

public static void main(String[] args) {
    // skip()와 limit(): 요소 건너뛰기와 제한
    Stream.of(1, 2, 3, 4, 5)
            .skip(2)
            .limit(2)
            .forEach(System.out::println);

    // filter()와 distinct(): 요소 걸러내기와 중복 제거
    Stream.of(1, 2, 3, 4, 5, 1, 2, 3)
            .filter(i -> i % 2 == 0)
            .distinct()
            .forEach(System.out::println);

    // sorted(): 요소 정렬
    Stream.of(5, 2, 1, 4, 3)
            .sorted()
            .forEach(System.out::println);

    // map(): 요소 변환
    Stream.of(1, 2, 3, 4, 5)
            .map(i -> i * 2)
            .forEach(System.out::println);

    // peek(): 요소 확인 (소비하지 않음)
    Stream.of(1, 2, 3, 4, 5)
            .peek(System.out::println)
            .forEach(System.out::println);

    // mapToInt(), mapToLong(), mapToDouble(): 기본형 스트림으로 변환
    Stream.of(1, 2, 3, 4, 5)
            .mapToInt(Integer::intValue)
            .forEach(System.out::println);

    // flatMap(): 스트림의 요소를 다른 스트림으로 변환하는 연산
    String[] lineArr = {
            "Believe or not It is true",
            "Do or do not There is no try"
    };

    Stream<String> lineStream = Stream.of(lineArr);
    Stream<Stream<String>> strArrStream = lineStream.map(line -> Stream.of(line.split(" +")));
    strArrStream.map(strStream -> Arrays.toString(strStream.toArray(String[]::new)))
            .forEach(System.out::println);
    // [[Believe, or, not, It, is, true], [Do, or, do, not, There, is, no, try]]

    lineStream = Stream.of(lineArr);
    Stream<String> stream = lineStream.flatMap(line -> Stream.of(line.split(" +")));
    stream.forEach(System.out::println);
    // [Believe, or, not, It, is, true, Do, or, do, not, There, is, no, try]
}

스트림의 최종 연산

public static void main(String[] args) {
    // forEach(): 스트림 요소를 소모하면서 작업 수행
    Stream.of(1, 2, 3, 4, 5).forEach(System.out::println);

    // allMatch(), anyMatch(), noneMatch(): 요소에 대해 지정된 조건에 맞는지 검사하는 연산으로 boolean 값을 반환
    Stream.of(1, 2, 3, 4, 5).allMatch(i -> i > 0); // true
    Stream.of(1, 2, 3, 4, 5).anyMatch(i -> i > 2); // true
    Stream.of(1, 2, 3, 4, 5).noneMatch(i -> i > 0); // false

    // findFirst()와 findAny(): 스트림의 요소 중에서 찾은 첫 번째 요소를 `Optional` 객체로 반환(찾지 못하면 empty 상태의 `Optional` 객체 반환)
    Stream.of(1, 2, 3, 4, 5).findFirst(); // Optional[1]
    Stream.of(1, 2, 3, 4, 5).findAny(); // Optional[1]

    // reduce(): 스트림의 요소를 하나씩 소모하면서 지정된 람다식을 수행하는 연산으로 `Optional` 객체를 반환
    // reduce()를 사용하면 sum(), max(), min() 등의 집계 연산을 구현할 수 있다.
    Stream.of(1, 2, 3, 4, 5).reduce((a, b) -> a + b); // Optional[15]

    // count(), max(), min(): 스트림의 요소를 소모하면서 지정된 연산을 수행하고, 최종 결과를 반환
    Stream.of(1, 2, 3, 4, 5).count(); // 5
    Stream.of(1, 2, 3, 4, 5).max(Integer::compareTo); // Optional[5]
    Stream.of(1, 2, 3, 4, 5).min(Integer::compareTo); // Optional[1]

    // collect(): 스트림의 요소를 수집하는 연산으로, `Collector`를 매개변수로 받아 받은 타입으로 변환하여 반환
    List<Integer> list = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toList());
    Set<Integer> set = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toSet());
}

findFirst() vs findAny()

findFirst()와 findAny() 두 메서드 모두 찾은 첫 번째 요소를 Optional 객체로 반환하지만, 병렬 환경에서 동작이 다르다.

findFirst(): 여러 요소가 조건에 부합해도 Stream의 순서를 고려하여 첫 번째 요소를 반환
findAny(): Multiple Thread에서 여러 요소를 처리하다가 가장 먼저 찾은 요소를 반환

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

    Optional<Integer> findFirst = list.stream().parallel().filter(i -> i % 2 == 0).findFirst();
    Optional<Integer> findAny = list.stream().parallel().filter(i -> i % 2 == 0).findAny();

    System.out.println(findFirst.get()); // 2
    System.out.println(findAny.get()); // 2, 4, 6, 8, 10 중 하나
}

기본형 스트림 (Primitive Stream)

Stream<Integer>, Stream<Double> 등을 사용하면 기본형과 객체 간의 변환(박싱, 언박싱) 오버헤드가 발생할 수 있기 때문에, 기본형을 직접 다루는 스트림을 사용하는 것이 좋다.

Stream<T>.mapToInt(ToIntFunction<T> mapper): Stream<T>를 IntStream으로 변환한
IntStream.sum(), IntStream.average(): 기본형에 특화된 집계 메서드 제공
IntStream.boxed(): IntStream을 다시 Stream<Integer>로 변환
IntStream, LongStream, DoubleStream 사용 가능

참고자료

Java의 정석

Last updated 14 days ago

Was this helpful?