17370845950

在日常数据处理中，我们经常会遇到需要统计列表中特定类别元素出现频率的场景。例如，在一个包含家庭成员信息的列表中，我们可能需要统计不同类型的家庭成员（如兄弟姐妹、子女、配偶）各自有多少人。原始数据可能以 list

  | Add_Family_Member | Full_Name     | Date_Of_Birth | Gender |
  | Sibling           | Sibling name  | 12-12-1990    | Male   |
  | Sibling           | Sibling name2 | 12-12-1990    | Male   |
  | Sibling           | Sibling name2 | 12-12-1990    | Male   |
  | Child             | Child name    | 12-12-2010    | Male   |
  | Child             | Child name2   | 12-12-2000    | Female |
  | Spouse            | Spouse name   | 12-12-1990    | Male   |

我们的目标是高效地统计出 "Sibling" 有 3 个，"Child" 有 2 个，"Spouse" 有 1 个。

优化数据结构：使用POJO类

虽然 List

以下是 FamilyMember POJO 类的定义：

import java.time.LocalDate; // Java 8日期API

public class FamilyMember {

    private String memberType;
    private String fullName;
    private LocalDate dateOfBirth;
    private String gender;

    public FamilyMember(String memberType, String fullName,
                        LocalDate dateOfBirth, String gender) {
        this.memberType = memberType;
        this.fullName = fullName;
        this.dateOfBirth = dateOfBirth;
        this.gender = gender;
    }

    // Getters
    public String getMemberType() {
        return memberType;
    }

    public String getFullName() {
        return fullName;
    }

    public LocalDate getDateOfBirth() {
        return dateOfBirth;
    }

    public String getGender() {
        return gender;
    }

    // Setters (可选，根据业务需求添加)
    public void setMemberType(String memberType) {
        this.memberType = memberType;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    public void setDateOfBirth(LocalDate dateOfBirth) {
        this.dateOfBirth = dateOfBirth;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

使用Java 8 Stream进行数据统计

Java 8 引入的 Stream API 提供了强大且富有表现力的数据处理能力。结合 Collectors.groupingBy() 和 Collectors.counting()，我们可以非常简洁地实现按类型计数的需求。

1. Collectors.groupingBy(Function classifier): 这个收集器根据提供的分类函数对流中的元素进行分组。分类函数会为每个元素生成一个键，所有具有相同键的元素将被分到同一个组中。
2. Collectors.counting(): 这是一个下游收集器，用于计算每个组中元素的数量。它通常与 groupingBy 结合使用，作为分组后的聚合操作。

下面是具体的实现代码，展示了如何使用 FamilyMember POJO 和 Stream API 进行统计：

import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class FamilyMemberCounter {

    public static void main(String[] args) {
        // 1. 创建FamilyMember对象列表作为示例数据
        List listOfFamilyMember = Arrays.asList(
            new FamilyMember("Sibling", "Sibling name", LocalDate.of(1990, 12, 12), "Male"),
            new FamilyMember("Sibling", "Sibling name2", LocalDate.of(1990, 12, 12), "Male"),
            new FamilyMember("Sibling", "Sibling name3", LocalDate.of(1990, 12, 12), "Male"),
            new FamilyMember("Child", "Child name", LocalDate.of(2010, 12, 12), "Male"),
            new FamilyMember("Child", "Child name2", LocalDate.of(2000, 12, 12), "Female"),
            new FamilyMember("Spouse", "Spouse name", LocalDate.of(1990, 12, 12), "Male")
        );

        // 2. 使用Stream API进行分组和计数
        // 将列表转换为流，然后使用Collectors.groupingBy按memberType分组，并用Collectors.counting统计每个组的数量
        Map countMembers = listOfFamilyMember.stream()
            .collect(Collectors.groupingBy(FamilyMember::getMemberType, // 分组依据：FamilyMember的memberType属性
                                           Collectors.counting()));    // 对每个分组内的元素进行计数

        // 3. 打印结果
        System.out.println(countMembers);
    }
}

代码解析：

• listOfFamilyMember.stream(): 首先将 List 转换为一个 Stream，这是进行流式操作的起点。
• .collect(...): 这是终端操作，用于将流中的元素收集到一个结果容器中。
• Collectors.groupingBy(FamilyMember::getMemberType, Collectors.counting()): 这是核心的收集器组合。
  • FamilyMember::getMemberType 是一个方法引用，它作为 groupingBy 的分类函数。它告诉 groupingBy 收集器，根据每个 FamilyMember 对象的 getMemberType() 方法返回的值（即 "Sibling", "Child", "Spouse" 等）来对元素进行分组。
  • Collectors.counting() 作为 groupingBy 的下游收集器。对于 groupingBy 创建的每个分组（例如，所有 "Sibling" 构成的组），counting() 会计算该组中元素的数量。
• 最终，collect 方法返回一个 Map，其中键是 memberType（如 "Sibling", "Child", "Spouse"），值是对应的计数。

输出结果：

{Spouse=1, Sibling=3, Child=2}

这个输出清晰地展示了每种家庭成员类型的数量，与我们的预期完全一致。

注意事项与最佳实践

1. 数据结构选择： 对于结构化数据，强烈建议优先使用POJO类而非泛型 Map。POJO提供了更好的类型安全、代码可读性、可维护性以及IDE的良好支持（如自动补全、重构）。
2. Stream API的优势： Java 8 Stream API 提供了声明式编程风格，使得数据处理逻辑更加简洁明了，能够写出更少、更易读的代码。对于大型数据集，Stream API 还能更好地利用多核处理器进行并行处理（通过调用 .parallelStream()），从而提高性能。
3. groupingBy 的灵活性： groupingBy 是一个非常强大的收集器，它不仅可以与 counting() 结合，还可以与许多其他下游收集器（如 summingInt、averagingDouble、mapping、reducing 等）结合，实现更复杂的数据聚合和转换需求。
4. 处理List 如果由于外部系统限制或其他原因，确实无法避免使用 List

总结

本文详细阐述了如何利用Java 8 Stream API中的 Collectors.groupingBy() 和 Collectors.counting() 功能，高效地统计集合中特定类型元素的出现次数。通过将原始的 List