场景描述
在实际开发中，我们经常需要处理包含多种类型或类别的数据集合。例如，给定一个building（建筑）对象的列表，每个building对象都包含price（价格）、neighborhood（社区）和category（类别）等属性。我们的目标是计算每个category下所有building的平均price，并将结果存储在一个map
为了更好地理解，我们首先定义相关的类结构：
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 +
'}';
}
}传统迭代方法的挑战
如果没有Java Stream API，我们可能需要通过多步迭代来完成这个任务：
- 创建一个Map
>来存储每个类别的所有价格。 - 遍历Building列表，将每个Building的价格根据其Category添加到对应的列表中。
- 再次遍历这个Map，对每个Category的价格列表计算平均值，并将结果存入最终的Map
。
这种方法代码量较大，逻辑分散，且容易出错。
使用Java Stream API的高效解决方案
Java 8引入的Stream API提供了一种声明式处理数据集合的强大方式。通过结合Collectors.groupingBy和Collectors.averagingDouble，我们可以用一行代码实现上述复杂的数据聚合逻辑。
立即学习“Java免费学习笔记（深入）”；
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 averagePricePerCategory(List 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 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 averagePrices = averagePricePerCategory(buildings);
System.out.println("各类别平均价格:");
averagePrices.forEach((category, avgPrice) ->
System.out.println(category.getName() + ": " + String.format("%.2f", avgPrice))
);
// 测试空列表情况
List emptyBuildings = new ArrayList<>();
Map emptyAveragePrices = averagePricePerCategory(emptyBuildings);
System.out.println("\n空列表的平均价格结果: " + emptyAveragePrices); // 预期输出 {}
}
} 代码解析
-
buildings.stream(): 首先，我们将输入的List
转换为一个Stream 。Stream API的所有操作都基于这个流。 - .collect(...): collect是一个终端操作，它会消费流中的元素，并将它们聚合为一个结果（这里是一个Map）。它接收一个Collector作为参数。
-
Collectors.groupingBy(classifier, downstreamCollector): 这是核心的聚合器。
- classifier (Building::getCategory): 这是一个函数，用于从流中的每个元素（Building对象）中提取用于分组的键。在这里，它会根据每个Building的Category属性进行分组。
- downstreamCollector (Collectors.averagingDouble(Building::getPrice)): 这是一个嵌套的收集器，用于处理每个分组内的元素。对于每个Category分组，averagingDouble会收集该分组内所有Building对象的price属性，并计算它们的平均值。
- Building::getPrice: 这是一个函数，用于从Building对象中提取需要计算平均值的double类型数值（这里int会被自动提升为double）。
最终，collect方法会返回一个Map
注意事项与总结
- 处理空列表: 在averagePricePerCategory方法中，我们添加了一个if (buildings == null || buildings.isEmpty())的检查。虽然Stream API在处理空流时通常会返回一个空集合或默认值（例如，averagingDouble在空分组上会返回0.0），但为了明确性及避免不必要的流操作，预先检查是一个良好的实践。
- 性能: 对于大规模数据集，Stream API在内部可以利用并行处理（通过parallelStream()），从而在多核处理器上提供更好的性能。然而，对于小规模数据集，并行流的开销可能会抵消其优势。
- 代码可读性: 相比于传统的循环和条件判断，Stream API的代码更具声明性，它描述了“做什么”而不是“如何做”，使得代码意图更清晰，更易于理解和维护。
- 类型安全: Stream API的操作都是类型安全的，编译器会在编译时捕获大部分类型错误。
- 可扩展性: 如果未来需要计算其他聚合指标（如总和、最大值、最小值、计数等），或者需要进行更复杂的组合聚合，Stream API提供了丰富的Collectors选项来满足这些需求。
通过本教程，我们了解了如何利用Java Stream API中的groupingBy和averagingDouble收集器，以一种简洁、高效且声明式的方式，从对象列表中聚合数据并计算按类别分组的平均值。掌握Stream API是现代Java开发中不可或缺的技能，它能显著提升代码质量和开发效率。
