Java8 Stream（8）List集合统计 求和 最大值 最小值 平均值

对集合数据的统计，是开发中常用的功能，掌握好Java Stream提供的方法，避免自己写代码统计，可以提高工作效率。

先造点数据：

pigs.add(new Pig(1, "猪爸爸", 31, "M", false));
pigs.add(new Pig(2, "猪妈妈", 28, "F", true));
pigs.add(new Pig(3, "乔治", 2, "M", false));
pigs.add(new Pig(4, "佩奇", 5, "F", false));

工作中常用的求和，可以用reduce，这是最为常见的，下面介绍一些更丰富的语法。

System.out.println("map reduce Integer::sum");
Integer sumAgeInt = pigs.stream()
         .map(User::getAge)
         .filter(Objects::nonNull)
         .reduce(0, Integer::sum);

一、统计个数

用Stream流中的count()函数可以方便的获取元素个数。

long count = pigs.stream().filter(a -> a.getAge() > 5).count();
System.out.println("age > 5的人数 = " + count);

二、利用数值流自带的函数

如果是数值流，可以利用它自带的sum、max、min、average这些函数。

流用一次就不能用第二次，每次都得重新创建流。

long count = pigs.stream().mapToInt(Pig::getAge).count();
int sumAge = pigs.stream().mapToInt(Pig::getAge).sum();
int maxAge = pigs.stream().mapToInt(Pig::getAge).max().getAsInt();
int minAge = pigs.stream().mapToInt(Pig::getAge).min().getAsInt();
double avgAge = pigs.stream().mapToInt(Pig::getAge).average().getAsDouble();

三、summaryStatistics统计

流用一次就不能用第二次，可以一次性获取一个流的所有统计信息。

IntSummaryStatistics statistics = pigs.stream().mapToInt(Pig::getAge).summaryStatistics();

System.out.println("count = " + statistics.getCount());
System.out.println("sumAge = " + statistics.getSum());
System.out.println("maxAge = " + statistics.getMax());
System.out.println("minAge = " + statistics.getMin());
System.out.println("avgAge = " + statistics.getAverage());

四、利用Collectors

1. 对象流

如果是对象流，想求某个值最大的对象，可以用Collectors

例如：求age最大的猪对象，age最小的猪对象

Optional<Pig> pigMaxAgeOptional = pigs.stream().collect(Collectors.maxBy(comparing(Pig::getAge)));
if (pigMaxAgeOptional.isPresent()){
    System.out.println("age最大的猪 = " + pigMaxAgeOptional.get());
}

Optional<Pig> pigMinAgeOptional = pigs.stream().collect(Collectors.minBy(comparing(Pig::getAge)));
if (pigMinAgeOptional.isPresent()){
    System.out.println("age最小的猪 = " + pigMinAgeOptional.get());
}

结果如下：

age最大的猪 = Pig(id=1, name=猪爸爸, age=31, gender=M, valid=false)
age最小的猪 = Pig(id=3, name=乔治, age=2, gender=M, valid=false)

1.1 先分组，再求和

对于Integer类型，利用Collectors.groupingBy和Collectors.summingInt求和

Map<String, Integer> groupByDeptThenGetSumAge = users.stream()
        .filter(user -> Objects.nonNull(user.getDept())) //比较的字段不能有null值
        .filter(user -> Objects.nonNull(user.getAge())) //比较的字段不能有null值
        .collect(
                Collectors.groupingBy(
                        User::getDept,
                        Collectors.summingInt(User::getAge)
                )
        );

对于BigDecimal类型，利用Collectors.groupingBy和Collectors.reducing求和

System.out.println("group by dept then get sum salary");
Map<String, BigDecimal> groupByDeptThenGetSumSalary = users.stream()
        .filter(user -> Objects.nonNull(user.getDept())) //比较的字段不能有null值
        .collect(
                Collectors.groupingBy(
                        User::getDept,
                        Collectors.reducing(
                                BigDecimal.ZERO,
                                User::getSalary,
                                BigDecimal::add
                        )
                )
        );

1.2 先分组，再求最大值

对于Integer类型，利用Collectors.groupingBy和Collectors.maxBy求最大值
如果是求最小值，换成minBy就可以了

Map<String, User> groupByDeptThenGetMaxAgeUser = users.stream()
        .filter(user -> Objects.nonNull(user.getDept())) //比较的字段不能有null值
        .filter(user -> Objects.nonNull(user.getAge())) //比较的字段不能有null值
        .collect(
                Collectors.groupingBy(
                        User::getDept,
                        Collectors.collectingAndThen(
                                Collectors.maxBy(
                                        Comparator.comparingInt(User::getAge)
                                ),
                                Optional::get
                        )

                )

        );

对于BigDecimal类型，利用Collectors.groupingBy和Collectors.reducing求最大值

System.out.println("group by dept then get max salary");
Map<String, BigDecimal> groupByDeptThenGetMaxSalary = users.stream()
        .filter(user -> Objects.nonNull(user.getDept())) //比较的字段不能有null值
        .collect(
                Collectors.groupingBy(
                        User::getDept,
                        Collectors.reducing(
                                BigDecimal.ZERO,
                                User::getSalary,
                                BigDecimal::max
                        )
                )
        );

1.3 先分组，再求最小值

对于BigDecimal类型，除了用上面的Collectors.groupingBy和Collectors.reducing组合，还可以使用Collectors.collectingAndThen。

System.out.println("group by dept then get min salary");
Map<String, BigDecimal> groupByDeptThenGetMinSalary = users.stream()
        .filter(user -> Objects.nonNull(user.getDept())) //比较的字段不能有null值
        .collect(
                Collectors.groupingBy(
                        User::getDept,
                        Collectors.collectingAndThen(
                                Collectors.reducing(
                                        (c1, c2) -> c1.getSalary().compareTo(c2.getSalary()) > 0 ? c2 : c1
                                ),
                                a -> a.isPresent() ? a.get().getSalary() : null
                        )
                )
        );

2. 数值流

Collections还提供了max、min

Set<Integer> ageSet = pigs.stream().map(Pig::getAge).collect(Collectors.toSet());

System.out.println("maxAge=" + Collections.max(ageSet));
System.out.println("minAge=" + Collections.min(ageSet));

3. 分组后，再map

System.out.println("group by dept then get name set");
Map<String, Set<String>> deptUserNameSet = users.stream()
        .filter(user -> Objects.nonNull(user.getDept()))
        .collect(
                Collectors.groupingBy(
                        User::getDept,
                        Collectors.mapping(
                                User::getName,
                                Collectors.toSet()
                        )
                )
        );

4. List<Map<String, Object>>上排序

List<Map<String, Object>> cats = new ArrayList<>();
Map<String,Object> cat1 = new HashMap<>();
cat1.put("name", "cat1");
cat1.put("age", 10);
cats.add(cat1);

Map<String,Object> cat2 = new HashMap<>();
cat2.put("name", "cat2");
cat2.put("age", 2);
cats.add(cat2);

List<Map<String, Object>> sortedCats = cats.stream().sorted((map1, map2) -> {
    int age1 = (int) map1.getOrDefault("age", 0);
    int age2 = (int) map2.getOrDefault("age", 0);
    return age1 - age2;
}).collect(Collectors.toList());

sortedCats.forEach(System.out::println);