Chapter 05. 스트림 활용

// 채식 요리만 필터링
List<Dish> vegetarianDishes = menu.stream()
    .filter(Dish::isVegetarian)
    .collect(toList());

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
    .filter(i -> i % 2 == 0)  // 짝수 필터링
    .distinct()                // 중복 제거
    .forEach(System.out::println);  // 2, 4

List<Dish> specialMenu = Arrays.asList(
    new Dish("seasonal fruit", true, 120, Dish.Type.OTHER),
    new Dish("prawns", false, 300, Dish.Type.FISH),
    new Dish("rice", true, 350, Dish.Type.OTHER),
    new Dish("chicken", false, 400, Dish.Type.MEAT),
    new Dish("french fries", true, 530, Dish.Type.OTHER)
);

// filter: 전체를 순회하며 조건 검사 (5개 요소 모두 검사)
List<Dish> filtered = specialMenu.stream()
    .filter(dish -> dish.getCalories() < 320)
    .collect(toList());  // [seasonal fruit, prawns]

// takeWhile: 조건이 거짓이 되면 즉시 중단 (3번째에서 중단)
List<Dish> sliced = specialMenu.stream()
    .takeWhile(dish -> dish.getCalories() < 320)
    .collect(toList());  // [seasonal fruit, prawns]

// 320칼로리 이상인 요리들
List<Dish> sliced = specialMenu.stream()
    .dropWhile(dish -> dish.getCalories() < 320)
    .collect(toList());  // [rice, chicken, french fries]

// 300칼로리 초과 요리 중 처음 3개만 선택
List<Dish> dishes = menu.stream()
    .filter(d -> d.getCalories() > 300)
    .limit(3)
    .collect(toList());

// 300칼로리 초과 요리 중 처음 2개를 건너뛰고 나머지 선택
List<Dish> dishes = menu.stream()
    .filter(d -> d.getCalories() > 300)
    .skip(2)
    .collect(toList());

// 페이지네이션 예시: 페이지당 10건, 3페이지 조회
int pageSize = 10;
int page = 3;
List<Dish> pageResult = menu.stream()
    .skip((long) (page - 1) * pageSize)
    .limit(pageSize)
    .collect(toList());

// 요리명 추출
List<String> dishNames = menu.stream()
    .map(Dish::getName)
    .collect(toList());

// 단어 길이 추출
List<String> words = Arrays.asList("Modern", "Java", "In", "Action");
List<Integer> wordLengths = words.stream()
    .map(String::length)
    .collect(toList());  // [6, 4, 2, 6]

// 요리명의 글자 수 추출
List<Integer> dishNameLengths = menu.stream()
    .map(Dish::getName)      // Stream<String>
    .map(String::length)     // Stream<Integer>
    .collect(toList());

List<String> words = Arrays.asList("Hello", "World");

// 잘못된 접근: map만 사용
words.stream()
    .map(word -> word.split(""))  // Stream<String[]>
    .distinct()
    .collect(toList());
// 결과: [["H","e","l","l","o"], ["W","o","r","l","d"]]
// String[] 단위로 비교하므로 의도와 다름

// 올바른 접근: flatMap 사용
List<String> uniqueChars = words.stream()
    .map(word -> word.split(""))     // Stream<String[]>
    .flatMap(Arrays::stream)         // Stream<String> (평면화)
    .distinct()
    .collect(toList());
// 결과: [H, e, l, o, W, r, d]

// 두 숫자 리스트의 모든 조합 쌍 생성
List<Integer> numbers1 = Arrays.asList(1, 2, 3);
List<Integer> numbers2 = Arrays.asList(3, 4);

List<int[]> pairs = numbers1.stream()
    .flatMap(i -> numbers2.stream()
        .map(j -> new int[]{i, j}))
    .collect(toList());
// [(1,3), (1,4), (2,3), (2,4), (3,3), (3,4)]

boolean hasVegetarian = menu.stream()
    .anyMatch(Dish::isVegetarian);  // true

boolean isHealthy = menu.stream()
    .allMatch(dish -> dish.getCalories() < 1000);

// allMatch의 반대
boolean isHealthy = menu.stream()
    .noneMatch(d -> d.getCalories() >= 1000);

Optional<Dish> dish = menu.stream()
    .filter(Dish::isVegetarian)
    .findAny();

// 제곱값 중 9로 나누어떨어지는 첫 번째 값
List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = someNumbers.stream()
    .map(n -> n * n)
    .filter(n -> n % 3 == 0)
    .findFirst();  // Optional[9]

// Optional 활용 예시
menu.stream()
    .filter(Dish::isVegetarian)
    .findAny()
    .ifPresent(dish -> System.out.println(dish.getName()));

// for 루프 방식
int sum = 0;
for (int x : numbers) {
    sum += x;
}

// reduce 방식
int sum = numbers.stream().reduce(0, (a, b) -> a + b);

// 메서드 참조
int sum = numbers.stream().reduce(0, Integer::sum);

Optional<Integer> sum = numbers.stream()
    .reduce((a, b) -> a + b);

// 최댓값
Optional<Integer> max = numbers.stream()
    .reduce(Integer::max);

// 최솟값
Optional<Integer> min = numbers.stream()
    .reduce(Integer::min);

// Stream<Dish> → IntStream
int totalCalories = menu.stream()
    .mapToInt(Dish::getCalories)  // IntStream 반환
    .sum();                       // int 반환 (기본값 0)

IntStream intStream = menu.stream()
    .mapToInt(Dish::getCalories);
Stream<Integer> stream = intStream.boxed();  // 다시 객체 스트림으로

OptionalInt maxCalories = menu.stream()
    .mapToInt(Dish::getCalories)
    .max();

int max = maxCalories.orElse(0);  // 값이 없으면 0

Stream<String> stream = Stream.of("Modern", "Java", "In", "Action");
stream.map(String::toUpperCase)
    .forEach(System.out::println);

// 빈 스트림
Stream<String> empty = Stream.empty();

// Java 9 이전
Stream<String> stream = System.getProperty("home") == null
    ? Stream.empty()
    : Stream.of(System.getProperty("home"));

// Java 9+
Stream<String> stream =
    Stream.ofNullable(System.getProperty("home"));

int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum();  // 41

// 파일의 고유 단어 수 세기
long uniqueWords = 0;
try (Stream<String> lines =
        Files.lines(Paths.get("data.txt"),
            Charset.defaultCharset())) {
    uniqueWords = lines
        .flatMap(line -> Arrays.stream(line.split(" ")))
        .distinct()
        .count();
} catch (IOException e) {
    // 예외 처리
}

// 0부터 시작하는 짝수 스트림
Stream.iterate(0, n -> n + 2)
    .limit(10)
    .forEach(System.out::println);
// 0, 2, 4, 6, 8, 10, 12, 14, 16, 18

// Java 9: Predicate를 받는 iterate (for 루프 대체)
IntStream.iterate(0, n -> n < 100, n -> n + 4)
    .forEach(System.out::println);

Stream.generate(Math::random)
    .limit(5)
    .forEach(System.out::println);