Java 8의 Stream API를 설명하고 주요 연산들을 예시와 함께 설명해주세요.

// 명령형 방식 (for-loop)
List<String> result = new ArrayList<>();
for (String name : names) {
    if (name.startsWith("A")) {
        result.add(name.toUpperCase());
    }
}

// Stream 방식 (선언적)
List<String> result = names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// 컬렉션으로부터
List<String> list = List.of("a", "b", "c");
Stream<String> streamFromList = list.stream();

// 배열로부터
String[] array = {"a", "b", "c"};
Stream<String> streamFromArray = Arrays.stream(array);

// 직접 생성
Stream<String> streamOf = Stream.of("a", "b", "c");

// 범위 (정수)
IntStream range = IntStream.range(1, 6);       // 1, 2, 3, 4, 5
IntStream rangeClosed = IntStream.rangeClosed(1, 5); // 1, 2, 3, 4, 5

// 무한 스트림
Stream<Integer> iterate = Stream.iterate(0, n -> n + 2).limit(5); // 0, 2, 4, 6, 8
Stream<Double> generate = Stream.generate(Math::random).limit(3);

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> evens = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());
// [2, 4, 6, 8, 10]

List<String> names = List.of("alice", "bob", "charlie");

List<String> upperNames = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
// [ALICE, BOB, CHARLIE]

List<Integer> nameLengths = names.stream()
    .map(String::length)
    .collect(Collectors.toList());
// [5, 3, 7]

List<List<Integer>> nested = List.of(
    List.of(1, 2, 3),
    List.of(4, 5),
    List.of(6, 7, 8, 9)
);

List<Integer> flat = nested.stream()
    .flatMap(Collection::stream) // 각 리스트를 스트림으로 펼침
    .collect(Collectors.toList());
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

// 단어 분리 예시
List<String> sentences = List.of("Hello World", "Java Stream");
List<String> words = sentences.stream()
    .flatMap(s -> Arrays.stream(s.split(" ")))
    .collect(Collectors.toList());
// [Hello, World, Java, Stream]

List<String> names = List.of("banana", "apple", "cherry");

List<String> sorted = names.stream()
    .sorted() // 자연 순서
    .collect(Collectors.toList());
// [apple, banana, cherry]

List<String> sortedByLength = names.stream()
    .sorted(Comparator.comparingInt(String::length))
    .collect(Collectors.toList());
// [apple, banana, cherry] → 길이 기준

List<Integer> nums = List.of(1, 2, 2, 3, 3, 3, 4);

List<Integer> unique = nums.stream()
    .distinct()
    .collect(Collectors.toList());
// [1, 2, 3, 4]

List<Integer> firstThree = nums.stream()
    .limit(3)
    .collect(Collectors.toList());
// [1, 2, 2]

List<Integer> afterTwo = nums.stream()
    .skip(2)
    .collect(Collectors.toList());
// [2, 3, 3, 3, 4]

List<String> names = List.of("Alice", "Bob", "Charlie", "Alice");

// List로 수집
List<String> list = names.stream().collect(Collectors.toList());

// Set으로 수집 (중복 제거)
Set<String> set = names.stream().collect(Collectors.toSet());

// Map으로 수집
Map<String, Integer> nameToLength = names.stream()
    .distinct()
    .collect(Collectors.toMap(
        name -> name,           // 키 매핑
        String::length          // 값 매핑
    ));
// {Alice=5, Bob=3, Charlie=7}

// 그룹화
Map<Integer, List<String>> byLength = names.stream()
    .collect(Collectors.groupingBy(String::length));
// {3=[Bob], 5=[Alice, Alice], 7=[Charlie]}

// 문자열 조인
String joined = names.stream()
    .collect(Collectors.joining(", ", "[", "]"));
// [Alice, Bob, Charlie, Alice]

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

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

// count
long count = numbers.stream().filter(n -> n > 3).count(); // 2

// anyMatch — 하나라도 조건 만족
boolean hasEven = numbers.stream().anyMatch(n -> n % 2 == 0); // true

// allMatch — 모두 조건 만족
boolean allPositive = numbers.stream().allMatch(n -> n > 0); // true

// noneMatch — 아무것도 조건 만족 안 함
boolean noneNegative = numbers.stream().noneMatch(n -> n < 0); // true

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

// 합산
int sum = numbers.stream().reduce(0, Integer::sum); // 15

// 최대값
Optional<Integer> max = numbers.stream().reduce(Integer::max); // Optional[5]

// 문자열 결합
List<String> words = List.of("Java", "is", "cool");
String sentence = words.stream().reduce("", (a, b) -> a + " " + b).strip();
// "Java is cool"

List<String> names = List.of("Charlie", "Alice", "Bob");

Optional<String> first = names.stream()
    .filter(n -> n.startsWith("A"))
    .findFirst(); // Optional[Alice]

Optional<String> shortest = names.stream()
    .min(Comparator.comparingInt(String::length)); // Optional[Bob]

Optional<String> longest = names.stream()
    .max(Comparator.comparingInt(String::length)); // Optional[Charlie]

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

// 최종 연산이 없으면 아무것도 실행되지 않음
Stream<Integer> stream = numbers.stream()
    .filter(n -> {
        System.out.println("filter: " + n);
        return n % 2 == 0;
    })
    .map(n -> {
        System.out.println("map: " + n);
        return n * 10;
    });
// 여기까지 아무 출력 없음!

List<Integer> result = stream.collect(Collectors.toList());
// 최종 연산 호출 시 비로소 실행됨
// filter: 1, filter: 2, map: 2, filter: 3, filter: 4, map: 4, filter: 5
// result: [20, 40]

// 직원 목록에서 부서별 평균 연봉 계산
Map<String, Double> avgSalaryByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.averagingDouble(Employee::getSalary)
    ));

// 상위 3명의 고연봉자 이름 조회
List<String> top3 = employees.stream()
    .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
    .limit(3)
    .map(Employee::getName)
    .collect(Collectors.toList());

// 전체 급여 합산
double totalSalary = employees.stream()
    .mapToDouble(Employee::getSalary)
    .sum();