JavaストリームAPIを使った複雑なデータ集計方法を徹底解説

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

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

List<String> result = filteredStream.collect(Collectors.toList());

List<String> names = Arrays.asList("Alice", "Bob", "Amanda", "Brian");
List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("A"))
                                  .collect(Collectors.toList());
System.out.println(filteredNames); // 出力: [Alice, Amanda]

List<String> names = Arrays.asList("Alice", "Bob", "Amanda", "Brian");
List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());
System.out.println(nameLengths); // 出力: [5, 3, 6, 5]

List<String> names = Arrays.asList("Alice", "Bob", "Amanda", "Brian");
List<String> result = names.stream()
                           .filter(name -> name.startsWith("A"))
                           .map(String::toUpperCase)
                           .collect(Collectors.toList());
System.out.println(result); // 出力: [ALICE, AMANDA]

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
String result = names.stream()
                     .collect(Collectors.joining(", "));
System.out.println(result); // 出力: Alice, Bob, Charlie, David

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
                                  .filter(name -> name.length() > 3)
                                  .collect(Collectors.toList());
System.out.println(filteredNames); // 出力: [Alice, Charlie, David]

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", "David");
String longestName = names.stream()
                          .reduce("", (a, b) -> a.length() > b.length() ? a : b);
System.out.println(longestName); // 出力: Charlie

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Anna");
Map<Integer, List<String>> groupedByLength = names.stream()
                                                 .collect(Collectors.groupingBy(String::length));
System.out.println(groupedByLength);
// 出力: {3=[Bob], 4=[Anna], 5=[Alice, David], 7=[Charlie]}

Map<Character, List<String>> groupedByInitial = names.stream()
                                                     .collect(Collectors.groupingBy(name -> name.charAt(0)));
System.out.println(groupedByInitial);
// 出力: {A=[Alice, Anna], B=[Bob], C=[Charlie], D=[David]}

Map<Boolean, List<String>> partitionedByLength = names.stream()
                                                      .collect(Collectors.partitioningBy(name -> name.length() >= 4));
System.out.println(partitionedByLength);
// 出力: {false=[Bob], true=[Alice, Charlie, David, Anna]}

class Product {
    String name;
    String category;
    double price;

    // コンストラクタとゲッターを定義
}

// サンプルデータの作成
List<Product> products = Arrays.asList(
    new Product("Laptop", "Electronics", 1200),
    new Product("TV", "Electronics", 800),
    new Product("Smartphone", "Electronics", 600),
    new Product("Book", "Books", 20),
    new Product("Notebook", "Books", 5)
);

// カテゴリごとに製品をグループ化し、それぞれのカテゴリで100ドル以上かどうかでパーティショニング
Map<String, Map<Boolean, List<Product>>> categorizedAndPartitioned = products.stream()
    .collect(Collectors.groupingBy(Product::getCategory,
            Collectors.partitioningBy(product -> product.getPrice() >= 100)));

System.out.println(categorizedAndPartitioned);

class Product {
    String name;
    String category;
    double price;

    // コンストラクタとゲッターを定義
}

// サンプルデータの作成
List<Product> products = Arrays.asList(
    new Product("Laptop", "Electronics", 1200),
    new Product("TV", "Electronics", 800),
    new Product("Smartphone", "Electronics", 600),
    new Product("Book", "Books", 20),
    new Product("Notebook", "Books", 5)
);

// カテゴリと価格帯でマルチレベルにグループ化
Map<String, Map<String, List<Product>>> multiLevelGrouped = products.stream()
    .collect(Collectors.groupingBy(Product::getCategory,
            Collectors.groupingBy(product -> product.getPrice() >= 100 ? "高価格" : "低価格")));

System.out.println(multiLevelGrouped);
// 出力: {Electronics={高価格=[Laptop, TV, Smartphone]}, Books={低価格=[Book, Notebook]}}

Optional<List<Product>> highPriceElectronics = Optional.ofNullable(multiLevelGrouped.get("Electronics"))
                                                      .map(subMap -> subMap.get("高価格"));
highPriceElectronics.ifPresent(System.out::println); // 出力: [Laptop, TV, Smartphone]

List<Product> allProducts = multiLevelGrouped.values().stream()
                                             .flatMap(subMap -> subMap.values().stream())
                                             .flatMap(List::stream)
                                             .collect(Collectors.toList());

System.out.println(allProducts);
// 出力: [Laptop, TV, Smartphone, Book, Notebook]

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> upperCaseNames = names.parallelStream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());
System.out.println(upperCaseNames); // 出力: [ALICE, BOB, CHARLIE, DAVID]

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int[] sum = {0};
numbers.parallelStream().forEach(num -> sum[0] += num); // スレッドセーフでない例
System.out.println(sum[0]); // 予期しない結果になる可能性がある

Map<String, Long> ipCount = logs.parallelStream()
                                .map(log -> log.getIpAddress())
                                .collect(Collectors.groupingBy(ip -> ip, Collectors.counting()));

import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.function.Supplier;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.Set;
import java.util.HashSet;

public class CustomCollectors {

    public static Collector<String, StringBuilder, String> joiningWithCommas() {
        return new Collector<String, StringBuilder, String>() {
            @Override
            public Supplier<StringBuilder> supplier() {
                return StringBuilder::new;
            }

            @Override
            public BiConsumer<StringBuilder, String> accumulator() {
                return (sb, s) -> {
                    if (sb.length() > 0) sb.append(", ");
                    sb.append(s);
                };
            }

            @Override
            public BinaryOperator<StringBuilder> combiner() {
                return (sb1, sb2) -> {
                    if (sb1.length() > 0) sb1.append(", ");
                    sb1.append(sb2);
                    return sb1;
                };
            }

            @Override
            public Function<StringBuilder, String> finisher() {
                return StringBuilder::toString;
            }

            @Override
            public Set<Characteristics> characteristics() {
                return new HashSet<>();
            }
        };
    }

    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        String result = names.stream()
                             .collect(joiningWithCommas());
        System.out.println(result); // 出力: Alice, Bob, Charlie, David
    }
}

import java.util.*;
import java.util.stream.*;

class Product {
    private String name;
    private String category;
    private double price;

    // コンストラクタとゲッターを定義

    public Product(String name, String category, double price) {
        this.name = name;
        this.category = category;
        this.price = price;
    }

    public String getName() { return name; }
    public String getCategory() { return category; }
    public double getPrice() { return price; }

    @Override
    public String toString() {
        return String.format("%s: $%.2f", name, price);
    }
}

public class CustomCollectors {

    public static Collector<Product, ?, Map<String, Optional<Product>>> highestPricedByCategory() {
        return Collectors.groupingBy(
            Product::getCategory,
            Collectors.reducing(BinaryOperator.maxBy(Comparator.comparingDouble(Product::getPrice)))
        );
    }

    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
            new Product("Laptop", "Electronics", 1200),
            new Product("TV", "Electronics", 800),
            new Product("Smartphone", "Electronics", 600),
            new Product("Book", "Books", 20),
            new Product("Notebook", "Books", 5)
        );

        Map<String, Optional<Product>> mostExpensiveByCategory = products.stream()
                                                                         .collect(highestPricedByCategory());

        System.out.println(mostExpensiveByCategory);
        // 出力: {Electronics=Optional[Laptop: $1200.00], Books=Optional[Book: $20.00]}
    }
}

import java.time.LocalDate;

class Sale {
    private String productName;
    private String category;
    private double price;
    private LocalDate date;

    public Sale(String productName, String category, double price, LocalDate date) {
        this.productName = productName;
        this.category = category;
        this.price = price;
        this.date = date;
    }

    public String getProductName() { return productName; }
    public String getCategory() { return category; }
    public double getPrice() { return price; }
    public LocalDate getDate() { return date; }

    @Override
    public String toString() {
        return String.format("Sale{productName='%s', category='%s', price=%.2f, date=%s}",
                productName, category, price, date);
    }
}

import java.util.*;
import java.util.stream.*;
import java.time.Month;

public class SalesAnalysis {
    public static void main(String[] args) {
        List<Sale> sales = Arrays.asList(
            new Sale("Laptop", "Electronics", 1200, LocalDate.of(2024, 1, 15)),
            new Sale("TV", "Electronics", 800, LocalDate.of(2024, 2, 20)),
            new Sale("Smartphone", "Electronics", 600, LocalDate.of(2024, 1, 10)),
            new Sale("Book", "Books", 20, LocalDate.of(2024, 3, 5)),
            new Sale("Notebook", "Books", 5, LocalDate.of(2024, 2, 15))
        );

        Map<Month, Double> totalSalesByMonth = sales.stream()
            .collect(Collectors.groupingBy(sale -> sale.getDate().getMonth(),
                    Collectors.summingDouble(Sale::getPrice)));

        System.out.println(totalSalesByMonth);
        // 出力: {JANUARY=1800.0, FEBRUARY=805.0, MARCH=20.0}
    }
}

Map<String, Long> salesCountByCategory = sales.stream()
    .collect(Collectors.groupingBy(Sale::getCategory, Collectors.counting()));

Map<String, Double> totalSalesByCategory = sales.stream()
    .collect(Collectors.groupingBy(Sale::getCategory, Collectors.summingDouble(Sale::getPrice)));

System.out.println(salesCountByCategory);
System.out.println(totalSalesByCategory);
// 出力: {Electronics=3, Books=2}
// 出力: {Electronics=2600.0, Books=25.0}

Optional<Sale> maxSale = sales.stream()
    .max(Comparator.comparingDouble(Sale::getPrice));

maxSale.ifPresent(sale -> System.out.println("最高売上額の製品: " + sale));
// 出力: 最高売上額の製品: Sale{productName='Laptop', category='Electronics', price=1200.00, date=2024-01-15}

List<String> numbers = Arrays.asList("1", "2", "three", "4");
List<Integer> parsedNumbers = numbers.stream()
    .map(number -> {
        try {
            return Integer.parseInt(number);
        } catch (NumberFormatException e) {
            System.err.println("変換エラー: " + number);
            return null; // または適切なデフォルト値
        }
    })
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

System.out.println(parsedNumbers); // 出力: [1, 2, 4]

public static Integer safeParseInt(String number) {
    try {
        return Integer.parseInt(number);
    } catch (NumberFormatException e) {
        System.err.println("変換エラー: " + number);
        return null; // または適切なデフォルト値
    }
}

// 使用例
List<Integer> parsedNumbers = numbers.stream()
    .map(SalesAnalysis::safeParseInt)
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

System.out.println(parsedNumbers); // 出力: [1, 2, 4]

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

Set<String> uniqueNames = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toSet());

List<String> longNames = names.stream()
    .filter(name -> name.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

List<String> sortedNames = names.parallelStream()
    .sorted()
    .collect(Collectors.toList());

Stream<String> stream = Stream.of("Alice", "Bob", "Charlie");
stream.forEach(System.out::println);
stream.forEach(System.out::println); // エラー: ストリームはすでに消費されています

Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1);
infiniteStream.limit(10).forEach(System.out::println); // 安全に使用するには制限を設ける

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
for (String name : names) {
    try {
        // 処理
        System.out.println(name.toUpperCase());
    } catch (Exception e) {
        System.err.println("エラー: " + e.getMessage());
    }
}

// Guavaを使用してリストをフィルタリング
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> filteredNames = Lists.newArrayList(Iterables.filter(names, name -> name.startsWith("A")));
System.out.println(filteredNames); // 出力: [Alice]

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 並列処理
    System.out.println("非同期タスクの実行");
});
future.join(); // 完了を待つ

class Student {
    String name;
    int grade;
    int mathScore;
    int englishScore;
    int scienceScore;

    // コンストラクタとゲッターを定義
}

// サンプルデータ
List<Student> students = Arrays.asList(
    new Student("Alice", 1, 90, 85, 80),
    new Student("Bob", 1, 60, 70, 80),
    new Student("Charlie", 2, 50, 40, 55),
    new Student("David", 2, 40, 35, 50),
    new Student("Eve", 3, 95, 100, 90)
);

// 1. 学年ごとの平均点を計算するコードを記述
Map<Integer, Double> averageScoresByGrade = students.stream()
    .collect(Collectors.groupingBy(Student::getGrade,
            Collectors.averagingDouble(student -> 
                (student.getMathScore() + student.getEnglishScore() + student.getScienceScore()) / 3.0)));
System.out.println(averageScoresByGrade);

// 2. 各学年で最も優秀な学生を特定するコードを記述
Map<Integer, Optional<Student>> topStudentByGrade = students.stream()
    .collect(Collectors.groupingBy(Student::getGrade,
            Collectors.maxBy(Comparator.comparingDouble(student -> 
                (student.getMathScore() + student.getEnglishScore() + student.getScienceScore()) / 3.0))));
System.out.println(topStudentByGrade);

// 3. 数学の点数が50点未満の学生をリストアップするコードを記述
List<Student> studentsWithLowMathScore = students.stream()
    .filter(student -> student.getMathScore() < 50)
    .collect(Collectors.toList());
System.out.println(studentsWithLowMathScore);

class Book {
    String title;
    String author;
    double price;
    int year;

    // コンストラクタとゲッターを定義
}

// サンプルデータ
List<Book> books = Arrays.asList(
    new Book("Java Programming", "John Doe", 40.0, 2019),
    new Book("Advanced Java", "Jane Smith", 50.0, 2021),
    new Book("Python Basics", "Emily White", 35.0, 2020),
    new Book("Machine Learning", "John Doe", 60.0, 2022)
);

// 1. 著者ごとの書籍の平均価格を計算するコードを記述
Map<String, Double> averagePriceByAuthor = books.stream()
    .collect(Collectors.groupingBy(Book::getAuthor,
            Collectors.averagingDouble(Book::getPrice)));
System.out.println(averagePriceByAuthor);

// 2. 2020年以降に発行された書籍をリストアップするコードを記述
List<Book> recentBooks = books.stream()
    .filter(book -> book.getYear() >= 2020)
    .collect(Collectors.toList());
System.out.println(recentBooks);

// 3. 最も高価な書籍を特定するコードを記述
Optional<Book> mostExpensiveBook = books.stream()
    .max(Comparator.comparingDouble(Book::getPrice));
mostExpensiveBook.ifPresent(System.out::println);

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

    // コンストラクタとゲッターを定義
}

// サンプルデータ
List<Employee> employees = Arrays.asList(
    new Employee("Alice", "HR", 70000),
    new Employee("Bob", "Engineering", 80000),
    new Employee("Charlie", "Engineering", 120000),
    new Employee("David", "Marketing", 60000),
    new Employee("Eve", "HR", 75000)
);

// 1. 部門ごとの平均給与を計算するコードを記述
Map<String, Double> averageSalaryByDepartment = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment,
            Collectors.averagingDouble(Employee::getSalary)));
System.out.println(averageSalaryByDepartment);

// 2. 最も高い給与の社員を特定するコードを記述
Optional<Employee> highestPaidEmployee = employees.stream()
    .max(Comparator.comparingDouble(Employee::getSalary));
highestPaidEmployee.ifPresent(System.out::println);

// 3. 全社員の給与合計を計算するコードを記述
double totalSalary = employees.stream()
    .mapToDouble(Employee::getSalary)
    .sum();
System.out.println(totalSalary);