java8stream做统计（分组后取最大最小，排序）

java8 stream代码

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class User implements Serializable {

    private static final long serialVersionUID = 1220193146286930256L;
    private String id;
    private String name;
    private String groupId;
    private int num;
    private int age;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGroupId() {
        return groupId;
    }

    public void setGroupId(String groupId) {
        this.groupId = groupId;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(String id, String name, String groupId, int num, int age) {
        this.id = id;
        this.name = name;
        this.groupId = groupId;
        this.num = num;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", groupId='" + groupId + '\'' +
                ", num=" + num +
                ", age=" + age +
                '}';
    }


    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList<>(10);
        list.add(new User("1", "1号", "A", 10, 10));
        list.add(new User("2", "2号", "A", 20, 10));
        list.add(new User("3", "3号", "E", 50, 12));
        list.add(new User("4", "4号", "B", 60, 20));
        list.add(new User("5", "5号", "C", 80, 40));
        list.add(new User("6", "6号", "B", 220, 20));
        list.add(new User("7", "7号", "A", 110, 2));
        list.add(new User("8", "8号", "D", 110, 68));
        //去重复获取组
        System.out.println("----------去重复获取组-------------------");
        list.stream().filter(distinctByKey(User::getGroupId)).map(User::getGroupId).forEach(s -> {
            System.out.println(s);
        });
        //从第2个开始(下标)
        System.out.println("-------------从第2个开始----------------");
        list.stream().skip(2).forEach(s -> {
            System.out.println(s);
        });
        //取10以内的
        System.out.println("-------------取10以内的----------------");
        list.stream().filter(user -> user.getAge() <= 10).forEach(s -> {
            System.out.println(s);
        });
        //取最大
        System.out.println("----------------取最大-------------");
        User user = list.stream().max(Comparator.comparing(User::getNum)).get();
        System.out.println(user);
        //分组求合
        System.out.println("---------------分组求合--------------");
        list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.summingInt(User::getNum))).forEach((k, v) -> {
            System.out.println("K:" + k + "-V:" + v);
        });
        //分组取组内最大
        System.out.println("--------------分组取组内最大---------------");
        list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.maxBy(Comparator.comparingInt(User::getNum)))).forEach((k, v) -> {
            System.out.println("K:" + k + "-V:" + v.get());
        });
        //分组取组内最小
        System.out.println("------------分组取组内最小-----------------");
        list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.minBy(Comparator.comparingInt(User::getNum)))).forEach((k, v) -> {
            System.out.println("K:" + k + "-V:" + v.get());
        });
        //分组聚合多列
        System.out.println("---------------分组聚合多列计算--------------");
        list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.collectingAndThen(Collectors.toList(), users -> {
            Double[] ints = new Double[2];
            Double asDouble1 = users.stream().mapToInt(User::getNum).average().getAsDouble();
            Double asDouble2 = users.stream().mapToInt(User::getAge).average().getAsDouble();
            ints[0] = asDouble1;
            ints[1] = asDouble2;
            return ints;
        }))).forEach((k, v) -> {
            System.out.println("K:" + k + "-V:" + v[0] + "," + v[1]);
        });
        //分组后组内排序
        System.out.println("---------------分组后组内排序--------------");
        list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.collectingAndThen(Collectors.toList(), users -> {
            users.sort(Comparator.comparing(User::getNum).reversed());
            return users;
        }))).forEach((k, v) -> {
            System.out.println("k:" + k);
            System.out.println("v----->:");
            v.forEach(s -> {
                System.out.println(s);
            });
        });

    }


}

运行结果
----------去重复获取组-------------------
A
E
B
C
D
-------------从第2个开始----------------
User{id=‘3’, name=‘3号’, groupId=‘E’, num=50, age=12}
User{id=‘4’, name=‘4号’, groupId=‘B’, num=60, age=20}
User{id=‘5’, name=‘5号’, groupId=‘C’, num=80, age=40}
User{id=‘6’, name=‘6号’, groupId=‘B’, num=220, age=20}
User{id=‘7’, name=‘7号’, groupId=‘A’, num=110, age=2}
User{id=‘8’, name=‘8号’, groupId=‘D’, num=110, age=68}
-------------取10以内的----------------
User{id=‘1’, name=‘1号’, groupId=‘A’, num=10, age=10}
User{id=‘2’, name=‘2号’, groupId=‘A’, num=20, age=10}
User{id=‘7’, name=‘7号’, groupId=‘A’, num=110, age=2}
----------------取最大-------------
User{id=‘6’, name=‘6号’, groupId=‘B’, num=220, age=20}
---------------分组求合--------------
K:A-V:140
K:B-V:280
K:C-V:80
K:D-V:110
K:E-V:50
--------------分组取组内最大---------------
K:A-V:User{id=‘7’, name=‘7号’, groupId=‘A’, num=110, age=2}
K:B-V:User{id=‘6’, name=‘6号’, groupId=‘B’, num=220, age=20}
K:C-V:User{id=‘5’, name=‘5号’, groupId=‘C’, num=80, age=40}
K:D-V:User{id=‘8’, name=‘8号’, groupId=‘D’, num=110, age=68}
K:E-V:User{id=‘3’, name=‘3号’, groupId=‘E’, num=50, age=12}
------------分组取组内最小-----------------
K:A-V:User{id=‘1’, name=‘1号’, groupId=‘A’, num=10, age=10}
K:B-V:User{id=‘4’, name=‘4号’, groupId=‘B’, num=60, age=20}
K:C-V:User{id=‘5’, name=‘5号’, groupId=‘C’, num=80, age=40}
K:D-V:User{id=‘8’, name=‘8号’, groupId=‘D’, num=110, age=68}
K:E-V:User{id=‘3’, name=‘3号’, groupId=‘E’, num=50, age=12}
---------------分组聚合多列计算--------------
K:A-V:46.666666666666664,7.333333333333333
K:B-V:140.0,20.0
K:C-V:80.0,40.0
K:D-V:110.0,68.0
K:E-V:50.0,12.0
---------------分组后组内排序--------------
Disconnected from the target VM, address: ‘127.0.0.1:55118’, transport: ‘socket’
k:A
v----->:
User{id=‘7’, name=‘7号’, groupId=‘A’, num=110, age=2}
User{id=‘2’, name=‘2号’, groupId=‘A’, num=20, age=10}
User{id=‘1’, name=‘1号’, groupId=‘A’, num=10, age=10}
k:B
v----->:
User{id=‘6’, name=‘6号’, groupId=‘B’, num=220, age=20}
User{id=‘4’, name=‘4号’, groupId=‘B’, num=60, age=20}
k:C
v----->:
User{id=‘5’, name=‘5号’, groupId=‘C’, num=80, age=40}
k:D
v----->:
User{id=‘8’, name=‘8号’, groupId=‘D’, num=110, age=68}
k:E
v----->:
User{id=‘3’, name=‘3号’, groupId=‘E’, num=50, age=12}