使用Java Stream API高效聚合数据：按类别计算平均价格

import java.util.Objects;

// 假设Category是一个枚举类型或简单类
class Category {
    private String name;

    public Category(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Category{" + "name='" + name + '\'' + '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Category category = (Category) o;
        return Objects.equals(name, category.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

class Building {
    private int price;
    private String neighborhood;
    private Category category;

    public Building(int price, String neighborhood, Category category) {
        this.price = price;
        this.neighborhood = neighborhood;
        this.category = category;
    }

    public int getPrice() {
        return price;
    }

    public String getNeighborhood() {
        return neighborhood;
    }

    public Category getCategory() {
        return category;
    }

    @Override
    public String toString() {
        return "Building{" +
               "price=" + price +
               ", neighborhood='" + neighborhood + '\'' +
               ", category=" + category +
               '}';
    }
}

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.HashMap;
import java.util.ArrayList;

public class BuildingPriceCalculator {

    /**
     * 计算每个类别的平均建筑价格。
     *
     * @param buildings 建筑对象列表。
     * @return 一个Map，键是Category，值是该类别的平均价格。
     */
    public static Map<Category, Double> averagePricePerCategory(List<Building> buildings) {
        // 如果输入列表为空，直接返回一个空Map
        if (buildings == null || buildings.isEmpty()) {
            return new HashMap<>();
        }

        return buildings.stream() // 将List转换为Stream
                        .collect(Collectors.groupingBy( // 使用groupingBy进行分组
                                Building::getCategory, // 根据Building的Category属性进行分组
                                Collectors.averagingDouble(Building::getPrice) // 对每个分组内的Building，计算其price的平均值
                        ));
    }

    public static void main(String[] args) {
        // 示例数据
        Category residential = new Category("Residential");
        Category commercial = new Category("Commercial");
        Category industrial = new Category("Industrial");

        List<Building> buildings = new ArrayList<>();
        buildings.add(new Building(100000, "Downtown", residential));
        buildings.add(new Building(150000, "Suburb", residential));
        buildings.add(new Building(200000, "City Center", commercial));
        buildings.add(new Building(50000, "Outskirts", industrial));
        buildings.add(new Building(120000, "Downtown", residential));
        buildings.add(new Building(250000, "Financial District", commercial));

        Map<Category, Double> averagePrices = averagePricePerCategory(buildings);

        System.out.println("各类别平均价格:");
        averagePrices.forEach((category, avgPrice) ->
                System.out.println(category.getName() + ": " + String.format("%.2f", avgPrice))
        );

        // 测试空列表情况
        List<Building> emptyBuildings = new ArrayList<>();
        Map<Category, Double> emptyAveragePrices = averagePricePerCategory(emptyBuildings);
        System.out.println("\n空列表的平均价格结果: " + emptyAveragePrices); // 预期输出 {}
    }
}