一个较为复杂的Stream代码示例

这里是一个较为复杂的Stream操作示例，供大家参考。
我们可以设想一个场景，其中我们有一个用户列表，每个用户都有多个订单，每个订单有多个产品，我们需要找出所有用户中年龄超过30岁、居住在特定城市、并且至少有一个订单总价超过1000元的用户，同时统计这些用户的所有订单中产品的总数量。

下面是一个基于这个场景的Java代码示例，使用了Stream API的各种高级特性，如flatMap、filter、map、collect、groupingBy、reducing和filtering：

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

class Product {
    private String name;
    private double price;

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

    public double getPrice() {
        return price;
    }
}

class Order {
    private List<Product> products;

    public Order(List<Product> products) {
        this.products = products;
    }

    public List<Product> getProducts() {
        return products;
    }
}

class User {
    private String name;
    private int age;
    private String city;
    private List<Order> orders;

    public User(String name, int age, String city, List<Order> orders) {
        this.name = name;
        this.age = age;
        this.city = city;
        this.orders = orders;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    public List<Order> getOrders() {
        return orders;
    }
}

public class ComplexStreamExample {
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();

        // 假设这里填充了users列表...

        // 复杂的Stream操作
        Map<String, Long> result = users.stream()
            .filter(user -> user.getAge() > 30 && "New York".equals(user.getCity()))
            .flatMap(user -> user.getOrders().stream())
            .filter(order -> order.getProducts().stream()
                                  .mapToDouble(Product::getPrice)
                                  .sum() > 1000)
            .collect(Collectors.groupingBy(Order::hashCode,
                                           Collectors.reducing(0L,
                                                               order -> (long) order.getProducts().size(),
                                                               Long::sum)));

        // 打印结果
        result.forEach((k, v) -> System.out.println("Order count for key " + k + ": " + v));
    }
}

请注意，上面的示例中Order::hashCode在groupingBy中的使用可能是误导性的，因为Order的hashCode可能不会唯一标识一个订单，特别是在并行流中。在实际应用中，你可能需要使用更稳定和唯一的标识符来分组，例如Order的ID。

这个示例展示了如何使用流API来过滤、映射和聚合复杂的数据结构，但它也可以进一步优化和改进，例如，确保在groupingBy和reducing中使用更合理的键，以及可能的并行处理。此外，实际应用中可能需要考虑性能和内存使用，特别是在处理大数据集时。