Javaのラムダ式でコレクションの集計と統計処理をマスターしよう

(引数リスト) -> { 式またはステートメント; }

numbers.forEach(n -> System.out.println(n * 2));

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

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .reduce(0, (subtotal, element) -> subtotal + element);
System.out.println("Sum: " + sum);

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
double average = numbers.stream()
    .collect(Collectors.averagingDouble(num -> num));
System.out.println("Average: " + average);

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int max = numbers.stream()
    .max(Integer::compare)
    .orElseThrow(NoSuchElementException::new);
int min = numbers.stream()
    .min(Integer::compare)
    .orElseThrow(NoSuchElementException::new);

System.out.println("Max: " + max);
System.out.println("Min: " + min);

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Map<Boolean, List<Integer>> groupedByEvenOdd = numbers.stream()
    .collect(Collectors.groupingBy(num -> num % 2 == 0));

System.out.println("Even numbers: " + groupedByEvenOdd.get(true));
System.out.println("Odd numbers: " + groupedByEvenOdd.get(false));

class Student {
    String name;
    String subject;
    int score;

    Student(String name, String subject, int score) {
        this.name = name;
        this.subject = subject;
        this.score = score;
    }
}

List<Student> students = Arrays.asList(
    new Student("Alice", "Math", 85),
    new Student("Bob", "Math", 90),
    new Student("Charlie", "Science", 95),
    new Student("David", "Science", 80),
    new Student("Eve", "Math", 70)
);

Map<String, Double> averageScoresBySubject = students.stream()
    .collect(Collectors.groupingBy(
        student -> student.subject,
        Collectors.averagingInt(student -> student.score)
    ));

System.out.println("Average Scores by Subject: " + averageScoresBySubject);

Map<String, IntSummaryStatistics> scoreStatisticsBySubject = students.stream()
    .collect(Collectors.groupingBy(
        student -> student.subject,
        Collectors.summarizingInt(student -> student.score)
    ));

scoreStatisticsBySubject.forEach((subject, stats) -> {
    System.out.println(subject + " - Max: " + stats.getMax() + ", Min: " + stats.getMin() + ", Average: " + stats.getAverage());
});

List<Student> students = Arrays.asList(
    new Student("Alice", "Math", 85),
    new Student("Bob", "Math", 90),
    new Student("Charlie", "Science", 95),
    new Student("David", "Science", 80),
    new Student("Eve", "Math", 70)
);

double averageHighMathScores = students.stream()
    .filter(student -> student.subject.equals("Math") && student.score >= 80)
    .collect(Collectors.averagingInt(student -> student.score));

System.out.println("Average high Math scores: " + averageHighMathScores);

class Student {
    String name;
    String subject;
    int score;
    String gender;

    Student(String name, String subject, int score, String gender) {
        this.name = name;
        this.subject = subject;
        this.score = score;
        this.gender = gender;
    }
}

List<Student> students = Arrays.asList(
    new Student("Alice", "Math", 85, "Female"),
    new Student("Bob", "Math", 90, "Male"),
    new Student("Charlie", "Science", 95, "Male"),
    new Student("David", "Science", 80, "Male"),
    new Student("Eve", "Math", 70, "Female")
);

Map<String, Map<String, Double>> averageScoresBySubjectAndGender = students.stream()
    .collect(Collectors.groupingBy(
        student -> student.subject,
        Collectors.groupingBy(
            student -> student.gender,
            Collectors.averagingInt(student -> student.score)
        )
    ));

System.out.println("Average Scores by Subject and Gender: " + averageScoresBySubjectAndGender);

double overallAverage = students.stream()
    .collect(Collectors.averagingInt(student -> student.score));

List<Student> aboveAverageStudents = students.stream()
    .filter(student -> student.score > overallAverage)
    .collect(Collectors.toList());

System.out.println("Students above average score: " + aboveAverageStudents);

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

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

    double totalSales() {
        return quantitySold * price;
    }
}

List<Product> products = Arrays.asList(
    new Product("Laptop", "Electronics", 10, 800.0),
    new Product("Smartphone", "Electronics", 30, 500.0),
    new Product("Tablet", "Electronics", 20, 300.0),
    new Product("Headphones", "Accessories", 50, 50.0),
    new Product("Charger", "Accessories", 100, 20.0)
);

Map<String, Double> totalSalesByCategory = products.stream()
    .collect(Collectors.groupingBy(
        product -> product.category,
        Collectors.summingDouble(Product::totalSales)
    ));

System.out.println("Total Sales by Category: " + totalSalesByCategory);

Product bestSeller = products.stream()
    .max(Comparator.comparingInt(product -> product.quantitySold))
    .orElseThrow(NoSuchElementException::new);

System.out.println("Best Selling Product: " + bestSeller.name + " with " + bestSeller.quantitySold + " units sold.");

Map<String, Double> averagePriceByCategory = products.stream()
    .collect(Collectors.groupingBy(
        product -> product.category,
        Collectors.averagingDouble(product -> product.price)
    ));

System.out.println("Average Price by Category: " + averagePriceByCategory);

double threshold = 100.0;
long totalUnitsSold = products.stream()
    .mapToInt(product -> product.quantitySold)
    .sum();

long highValueUnitsSold = products.stream()
    .filter(product -> product.price > threshold)
    .mapToInt(product -> product.quantitySold)
    .sum();

double percentageHighValueSales = ((double) highValueUnitsSold / totalUnitsSold) * 100;

System.out.println("Percentage of Units Sold for High Value Products (> $" + threshold + "): " + percentageHighValueSales + "%");

List<Product> filteredProducts = products.stream()
    .filter(product -> product.getPrice() > 50 && product.getQuantitySold() > 10)
    .collect(Collectors.toList());

boolean hasExpensiveItem = products.stream()
    .anyMatch(product -> product.getPrice() > 1000);

IntStream quantityStream = products.stream()
    .mapToInt(Product::getQuantitySold);
int totalQuantity = quantityStream.sum();

List<String> productNames = products.stream()
    .filter(product -> product.getPrice() > 50)
    .map(Product::getName)
    .collect(Collectors.toList());

double totalSales = products.parallelStream()
    .mapToDouble(Product::totalSales)
    .sum();

Collector<Product, ?, Map<String, List<Product>>> customCollector = 
    Collectors.groupingBy(Product::getCategory);

Map<String, List<Product>> productsByCategory = products.stream()
    .collect(customCollector);

Map<String, Product> productMap = products.stream()
    .collect(Collectors.toMap(Product::getName, product -> product));

List<Product> products = Arrays.asList(
    new Product("Laptop", "Electronics", 10, 800.0),
    new Product("Smartphone", "Electronics", 30, 500.0),
    new Product("Tablet", "Electronics", 20, 300.0),
    new Product("Headphones", "Accessories", 50, 50.0),
    new Product("Charger", "Accessories", 100, 20.0)
);

double totalSales = products.parallelStream()
    .mapToDouble(Product::totalSales)
    .sum();

System.out.println("Total Sales: " + totalSales);

ForkJoinPool customThreadPool = new ForkJoinPool(4); // 4スレッドに制限
customThreadPool.submit(() -> {
    double totalSales = products.parallelStream()
        .mapToDouble(Product::totalSales)
        .sum();
    System.out.println("Total Sales with custom thread pool: " + totalSales);
}).join();
customThreadPool.shutdown();

List<Product> result = Collections.synchronizedList(new ArrayList<>());
products.parallelStream().forEach(product -> {
    if (product.getPrice() > 50) {
        result.add(product);
    }
});

List<String> data = Arrays.asList("100", "200", "invalid", "300");
List<Integer> numbers = data.stream()
    .map(value -> {
        try {
            return Integer.parseInt(value);
        } catch (NumberFormatException e) {
            throw new RuntimeException("Invalid number format: " + value, e);
        }
    })
    .collect(Collectors.toList());

System.out.println(numbers);

public static <T, R> Function<T, R> wrapFunction(FunctionWithException<T, R> function) {
    return t -> {
        try {
            return function.apply(t);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}

List<Integer> safeNumbers = data.stream()
    .map(wrapFunction(Integer::parseInt))
    .collect(Collectors.toList());

System.out.println(safeNumbers);

Queue<Throwable> exceptions = new ConcurrentLinkedQueue<>();

List<Integer> results = data.parallelStream()
    .map(value -> {
        try {
            return Integer.parseInt(value);
        } catch (NumberFormatException e) {
            exceptions.add(e);
            return null;
        }
    })
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

if (!exceptions.isEmpty()) {
    throw new RuntimeException("Errors occurred during processing", exceptions.peek());
}

System.out.println(results);

List<Integer> debugNumbers = data.stream()
    .peek(value -> System.out.println("Original value: " + value))
    .map(Integer::parseInt)
    .peek(number -> System.out.println("Parsed number: " + number))
    .collect(Collectors.toList());

System.out.println(debugNumbers);

Stream<String> initialStream = data.stream();
Stream<Integer> parsedStream = initialStream.map(Integer::parseInt);
List<Integer> finalList = parsedStream.collect(Collectors.toList());

System.out.println(finalList);

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

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

List<Product> products = Arrays.asList(
    new Product("Laptop", "Electronics", 1000.0, 30),
    new Product("Smartphone", "Electronics", 800.0, 50),
    new Product("Tablet", "Electronics", 500.0, 20),
    new Product("Headphones", "Accessories", 150.0, 100),
    new Product("Charger", "Accessories", 25.0, 200)
);

// TODO: Implement the solution to calculate the average price by category

// TODO: Implement the solution to filter products with quantitySold > 50

// TODO: Implement the solution to calculate total sales by category

// TODO: Implement the solution to find the most expensive product

// TODO: Implement the solution to calculate the median of quantitySold

// 解答例1: 商品カテゴリー別の平均価格を計算する
Map<String, Double> averagePriceByCategory = products.stream()
    .collect(Collectors.groupingBy(
        product -> product.category,
        Collectors.averagingDouble(product -> product.price)
    ));

// 解答例2: 売上数量が50を超える商品のリストを取得する
List<String> popularProducts = products.stream()
    .filter(product -> product.quantitySold > 50)
    .map(product -> product.name)
    .collect(Collectors.toList());

// 解答例3: カテゴリーごとの総売上を計算する
Map<String, Double> totalSalesByCategory = products.stream()
    .collect(Collectors.groupingBy(
        product -> product.category,
        Collectors.summingDouble(product -> product.price * product.quantitySold)
    ));

// 解答例4: 最高価格の商品を見つける
Product mostExpensiveProduct = products.stream()
    .max(Comparator.comparingDouble(product -> product.price))
    .orElseThrow(NoSuchElementException::new);

// 解答例5: 売上数量の中央値を計算する
List<Integer> sortedQuantities = products.stream()
    .map(product -> product.quantitySold)
    .sorted()
    .collect(Collectors.toList());
int middle = sortedQuantities.size() / 2;
double median = sortedQuantities.size() % 2 == 0 ? 
    (sortedQuantities.get(middle - 1) + sortedQuantities.get(middle)) / 2.0 :
    sortedQuantities.get(middle);