Java 8 Stream API：高效统计列表中元素出现次数

在实际开发中，我们经常需要对集合中的数据进行分类统计，例如统计不同类型元素的数量。当数据以list

数据结构优化：POJO的优势

原始数据以List

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

这种Map结构虽然灵活，但在访问字段时需要通过字符串键，容易出错且缺乏编译时检查。更推荐的做法是定义一个POJO（Plain Old Java Object）来封装这些属性，使其成为强类型数据：

import java.time.LocalDate;

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;
    }

    @Override
    public String toString() {
        return "FamilyMember{" +
               "memberType='" + memberType + '\'' +
               ", fullName='" + fullName + '\'' +
               ", dateOfBirth=" + dateOfBirth +
               ", gender='" + gender + '\'' +
               '}';
    }
}

使用FamilyMember对象列表List，我们可以更清晰、安全地操作数据。

Java 8 Stream API核心：groupingBy与counting

Java 8引入的Stream API提供了一种声明式处理集合数据的方式，极大地简化了复杂的数据操作。要统计列表中特定属性的出现次数，我们可以结合使用Collectors.groupingBy()和Collectors.counting()。

• Collectors.groupingBy(Function classifier): 这是一个强大的收集器，它根据提供的分类函数（classifier）对流中的元素进行分组。分类函数的返回值将作为结果Map的键，而值则是对应组的元素列表。
• Collectors.counting(): 这是一个下游收集器，通常与groupingBy结合使用。它简单地统计每个组中的元素数量，并将结果作为Long类型返回。

完整代码示例

以下代码展示了如何创建FamilyMember对象列表，并使用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 对象实例
        FamilyMember member1 = new FamilyMember("Sibling", "Sibling name",
                LocalDate.of(1990, 12, 12), "Male");
        FamilyMember member2 = new FamilyMember("Sibling", "Sibling name2",
                LocalDate.of(1990, 12, 12), "Male");
        FamilyMember member3 = new FamilyMember("Sibling", "Sibling name3",
                LocalDate.of(1990, 12, 12), "Male");
        FamilyMember member4 = new FamilyMember("Child", "Child name",
                LocalDate.of(2010, 12, 12), "Male");
        FamilyMember member5 = new FamilyMember("Child", "Child name2",
                LocalDate.of(2000, 12, 12), "Female");
        FamilyMember member6 = new FamilyMember("Spouse", "Spouse name",
                LocalDate.of(1990, 12, 12), "Male");

        // 2. 将对象放入列表中
        List listOfFamilyMember = Arrays.asList(member1, member2,
                member3, member4, member5, member6);

        // 3. 使用 Stream API 进行分组和计数
        Map countMembers = listOfFamilyMember.stream()
                .collect(Collectors.groupingBy(FamilyMember::getMemberType,
                        Collectors.counting()));

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

代码解析

1. 数据准备: 我们首先创建了FamilyMember的实例，并将其放入一个List中。
2. 创建流: listOfFamilyMember.stream()将列表转换为一个Stream对象，允许我们进行链式操作。
3. 收集器 Collectors.groupingBy():
   • FamilyMember::getMemberType 是一个方法引用，它作为分类函数。对于流中的每一个FamilyMember对象，它会调用getMemberType()方法来获取成员类型（如"Sibling", "Child", "Spouse"）。
   • Collectors.groupingBy()会以这些成员类型作为键，将相同的成员类型归为一组。
4. 下游收集器 Collectors.counting():
   • 对于groupingBy创建的每一个组，Collectors.counting()会计算该组中元素的数量。
   • 最终，collect()方法返回一个Map，其中键是成员类型（String），值是该类型成员的数量（Long）。

运行结果

执行上述代码，将得到如下输出：

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

这清晰地显示了每种家庭成员类型在列表中出现的次数。

总结与最佳实践

• 优先使用POJO: 对于结构化数据，强烈建议使用POJO类而非原始的Map。POJO提供了类型安全、更好的代码可读性、易于维护以及支持IDE的自动补全功能。
• Stream API的简洁性: Java 8 Stream API结合groupingBy和counting，提供了一种非常简洁且高效的方式来执行分组计数操作。它避免了手动迭代和维护计数器变量的繁琐。
• 可扩展性: 如果需要更复杂的聚合操作（例如计算平均值、求和等），groupingBy可以与Collectors类中的其他下游收集器（如averagingInt、summingInt、mapping等）结合使用，提供强大的数据处理能力。

通过掌握Java 8 Stream API，开发者可以更优雅、高效地处理集合数据，提升代码质量和开发效率。