Java Stream APIの基本と使い方：効果的なデータ処理の実践ガイド

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Stream<String> nameStream = names.stream();

int[] numbers = {1, 2, 3, 4, 5};
IntStream numberStream = Arrays.stream(numbers);

try (Stream<String> lines = Files.lines(Paths.get("example.txt"))) {
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

IntStream rangeStream = IntStream.range(1, 10);

Stream<String> filteredStream = nameStream.filter(name -> name.startsWith("A"));

Stream<Integer> lengthStream = nameStream.map(String::length);

Stream<String> sortedStream = nameStream.sorted();

List<String> nameList = nameStream.collect(Collectors.toList());

nameStream.forEach(System.out::println);

int totalLength = nameStream.map(String::length).reduce(0, Integer::sum);

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Anna");
Stream<String> filteredStream = names.stream()
                                     .filter(name -> name.startsWith("A"));

filteredStream.forEach(System.out::println); // 出力: Alice, Anna

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Stream<Integer> lengthStream = names.stream()
                                    .map(String::length);

lengthStream.forEach(System.out::println); // 出力: 5, 3, 7

List<String> names = Arrays.asList("Charlie", "Alice", "Bob");
Stream<String> sortedStream = names.stream()
                                   .sorted();

sortedStream.forEach(System.out::println); // 出力: Alice, Bob, Charlie

List<String> names = Arrays.asList("Charlie", "Alice", "Bob");
Stream<String> sortedByLengthStream = names.stream()
                                           .sorted(Comparator.comparingInt(String::length));

sortedByLengthStream.forEach(System.out::println); // 出力: Bob, Alice, Charlie

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> upperCaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

System.out.println(upperCaseNames); // 出力: [ALICE, BOB, CHARLIE]

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
     .forEach(System.out::println);

// 出力:
// Alice
// Bob
// Charlie

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .reduce(0, Integer::sum);

System.out.println(sum); // 出力: 15

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
String concatenatedNames = names.stream()
                                .reduce((a, b) -> a + ", " + b)
                                .orElse("");

System.out.println(concatenatedNames); // 出力: Alice, Bob, Charlie

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
names.parallelStream()
     .forEach(System.out::println);

names.parallelStream()
     .forEachOrdered(System.out::println);

int sum = IntStream.range(1, 1000000)
                   .parallel()
                   .filter(x -> x % 2 == 0)
                   .sum();

System.out.println("Sum: " + sum); // 出力: 249999500000

class Employee {
    String name;
    String department;
    double salary;

    // コンストラクタ、ゲッター、セッター省略
}

List<Employee> employees = Arrays.asList(
    new Employee("Alice", "HR", 50000),
    new Employee("Bob", "IT", 75000),
    new Employee("Charlie", "HR", 55000),
    new Employee("David", "IT", 80000),
    new Employee("Eve", "Marketing", 60000)
);

Map<String, Double> averageSalaries = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getSalary)));

averageSalaries.forEach((department, avgSalary) -> 
    System.out.println(department + ": " + avgSalary)
);

// 出力:
// HR: 52500.0
// IT: 77500.0
// Marketing: 60000.0

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

// 文字数が3文字以下の名前を大文字に変換してリストに格納
List<String> shortNamesUppercase = names.stream()
    .filter(name -> name.length() <= 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

System.out.println(shortNamesUppercase); // 出力: [BOB, EVE]

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

int sumOfEvenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .reduce(0, Integer::sum);

System.out.println("Sum of even numbers: " + sumOfEvenNumbers); // 出力: 30

List<Double> randomNumbers = new Random().doubles(1000000)
    .boxed()
    .collect(Collectors.toList());

List<Double> sortedNumbers = randomNumbers.parallelStream()
    .sorted()
    .collect(Collectors.toList());

System.out.println("First 10 sorted numbers: " + sortedNumbers.subList(0, 10));

List<String> result = names.stream()
    .filter(name -> name.length() > 3)
    .sorted()
    .skip(1)  // 最初の要素をスキップ
    .limit(2) // 2つの要素を取得
    .collect(Collectors.toList());

System.out.println(result); // 出力: [Charlie, David]

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

// 悪い例: 同じデータソースから複数回Streamを生成している
long count = names.stream().filter(name -> name.startsWith("A")).count();
List<String> filteredNames = names.stream().filter(name -> name.startsWith("A")).collect(Collectors.toList());

// 改善例: Streamを一度だけ生成し、結果を再利用する
Stream<String> stream = names.stream().filter(name -> name.startsWith("A"));
long count = stream.count();
// Streamは一度消費されると再利用できないため、再度フィルタリングが必要な場合はリストなどに一旦集約する
List<String> filteredNames = names.stream().filter(name -> name.startsWith("A")).collect(Collectors.toList());

// 悪い例: 不必要な操作を行っている
List<String> sortedFilteredNames = names.stream()
    .map(String::toLowerCase)
    .sorted()
    .filter(name -> name.startsWith("a"))
    .collect(Collectors.toList());

// 改善例: フィルタリング後に必要な操作を行う
List<String> sortedFilteredNames = names.stream()
    .filter(name -> name.toLowerCase().startsWith("a"))
    .sorted()
    .collect(Collectors.toList());

// 悪い例: forEachで要素を収集しようとしている
List<String> result = new ArrayList<>();
names.stream()
     .filter(name -> name.length() > 3)
     .forEach(result::add);

// 改善例: collect()を使用して結果を収集する
List<String> result = names.stream()
                           .filter(name -> name.length() > 3)
                           .collect(Collectors.toList());

// 悪い例: ステートフルなラムダ式の使用
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> results = new ArrayList<>();

numbers.stream()
       .map(n -> {
           results.add(n); // これはステートフルな操作です
           return n * 2;
       })
       .forEach(System.out::println);

// 改善例: ステートレスなラムダ式を使用
List<Integer> results = numbers.stream()
                               .map(n -> n * 2)
                               .collect(Collectors.toList());

results.forEach(System.out::println);

// 悪い例: 並列ストリームで順序が重要な処理を行う
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.parallelStream()
       .forEach(System.out::println); // 出力順序が保証されない

// 改善例: 順序を保証した並列処理
numbers.parallelStream()
       .forEachOrdered(System.out::println);

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

// Streamの再利用はできない
Stream<String> nameStream = names.stream();
nameStream.forEach(System.out::println);  // 終端操作

// nameStream.forEach(System.out::println);  // これはエラーになる

List<String> results = new ArrayList<>();
names.stream()
     .filter(name -> name.length() > 3)
     .forEach(results::add);  // 外部状態への操作は推奨されない

// 例外処理が難しい場合
List<String> lines = Files.lines(Paths.get("example.txt"))
                          .map(line -> {
                              try {
                                  return processLine(line);
                              } catch (IOException e) {
                                  throw new UncheckedIOException(e);
                              }
                          })
                          .collect(Collectors.toList());

Stream.of("Alice", "Bob", "Charlie")
      .filter(name -> {
          System.out.println("Filtering: " + name);
          return name.startsWith("A");
      })
      .map(name -> {
          System.out.println("Mapping: " + name);
          return name.toUpperCase();
      })
      .forEach(System.out::println);

// 並列処理が適用できない場合の例
Stream<String> stream = names.stream().sorted(); // 並列処理ではなく、シングルスレッドで処理される

// LinkedListを使用する場合、Stream APIよりも効率的な処理が必要になることがある
LinkedList<String> linkedList = new LinkedList<>(names);
linkedList.stream().filter(name -> name.startsWith("A")).collect(Collectors.toList());

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

// 偶数の合計を求める
int sumOfEvens = numbers.stream()
                        .filter(n -> n % 2 == 0)
                        .reduce(0, Integer::sum);
System.out.println("Sum of even numbers: " + sumOfEvens);

// 偶数の平方根をリストとして出力する
List<Double> squareRoots = numbers.stream()
                                  .filter(n -> n % 2 == 0)
                                  .map(Math::sqrt)
                                  .collect(Collectors.toList());
System.out.println("Square roots of even numbers: " + squareRoots);

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

// 4文字以上の名前を大文字に変換し、ソートしてリストにする
List<String> processedNames = names.stream()
                                   .filter(name -> name.length() >= 4)
                                   .map(String::toUpperCase)
                                   .sorted()
                                   .collect(Collectors.toList());
System.out.println("Processed names: " + processedNames);

class Employee {
    String name;
    int age;
    String department;

    // コンストラクタ、ゲッター、セッター省略
}

List<Employee> employees = Arrays.asList(
    new Employee("Alice", 25, "HR"),
    new Employee("Bob", 35, "IT"),
    new Employee("Charlie", 30, "HR"),
    new Employee("David", 45, "IT"),
    new Employee("Eve", 40, "Marketing")
);

// 部署ごとの平均年齢を計算し、30歳以上の部署を抽出する
Map<String, Double> departmentsWithAvgAgeAbove30 = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingInt(Employee::getAge)))
    .entrySet().stream()
    .filter(entry -> entry.getValue() >= 30)
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

departmentsWithAvgAgeAbove30.forEach((department, avgAge) -> 
    System.out.println(department + ": " + avgAge)
);

List<Integer> largeNumbers = new Random().ints(1_000_000, 1, 100)
                                         .boxed()
                                         .collect(Collectors.toList());

// 並列ストリームを使って偶数をフィルタリング
List<Integer> evenNumbers = largeNumbers.parallelStream()
                                        .filter(n -> n % 2 == 0)
                                        .collect(Collectors.toList());

System.out.println("Number of even numbers: " + evenNumbers.size());