Java8 排序、分组、统计、过滤

Java 8 Stream，可以以一种声明的方式处理数据，写出高效率、干净、简洁的代码，可以在节点上进行处理， 比如筛选， 排序，聚合等。

测试的实体：

@Data
public class City {

    private String cityName;//城市名称

    private Integer population;//人口

    private Integer rank;//排名

    private String province;//所属省份名称

    public City(String cityName, Integer population, Integer rank, String province) {
        this.cityName = cityName;
        this.population = population;
        this.rank = rank;
        this.province = province;
    }
}

测试排序、分组、统计、过滤：

    private static final List<String> sortArray = Arrays.asList("西安", "济南","洛阳","宝鸡","德州","开封","枣庄","榆林","郑州","菏泽","渭南","新乡");

    public static void main(String[] args) {

        List<City> list = new ArrayList<>();
        formData(list);//组建测试数据

        /*=========================排序====================================================*/

        //根据某个字段升序排序。注意：若是排序的字段值有空，此排序方式会报空指针异常，使用第二种排序方式
        list.sort(Comparator.comparing(City::getRank));
        list.sort(Comparator.comparing(City::getRank,Comparator.nullsFirst(Integer::compareTo)));
        //根据排名字段降序排序
        list.sort((e0, e1) -> e1.getRank().compareTo(e0.getRank()));
        list.sort(Comparator.comparing(City::getRank,Comparator.nullsFirst(Integer::compareTo)).reversed());
        //根据固定的城市名称顺序排列
        Collections.sort(list,(e0,e1) -> {
            int index0 = sortArray.indexOf(e0.getCityName());
            int index1 = sortArray.indexOf(e1.getCityName());
            return index0-index1;
        });
        System.out.println(JSONObject.toJSONString(list));

        //按照多个字段排序，先按照省份排序，后按照排名排序

        List<City> collect = list.stream().sorted(Comparator.comparing(City::getProvince).thenComparing(City::getRank)).collect(Collectors.toList());

        //先按照一个字段排序，再按照另一个字段降序
            list.sort(Comparator.comparing(City::getProvince).thenComparing(City::getRank,Comparator.reverseOrder()));
        System.out.println(list);

        //=======================分组================================
        //根据省份分组
        Map<String, List<City>> provinceMap = list.stream().collect(Collectors.groupingBy(City::getProvince));
        for (Map.Entry<String,List<City>> map: provinceMap.entrySet()) {
            System.out.println("省份:"+map.getKey()+"，城市："+map.getValue());
        }

        //根据省份+排名 分组
        Map<String, List<City>> provinceRankMap = list.stream().collect(Collectors.groupingBy(u->(u.getProvince()+"_"+u.getRank() )));
        for (Map.Entry<String,List<City>> map: provinceRankMap.entrySet()) {
            System.out.println("省份+排名:"+map.getKey()+"，城市："+map.getValue());
        }


        //根据省份分组求每省总人口
        Map<String, Integer> provinceSumMap = list.stream().collect(Collectors.groupingBy(City::getProvince,Collectors.summingInt(City::getPopulation)));
        for (Map.Entry<String,Integer> map: provinceSumMap.entrySet()) {
            System.out.println("省份:"+map.getKey()+"，人口："+map.getValue());
        }

        //根据省份分组求每省市平均人口
        Map<String, Double> provinceAvgMap = list.stream().collect(Collectors.groupingBy(City::getProvince,Collectors.averagingInt(City::getPopulation)));
        for (Map.Entry<String,Double> map: provinceAvgMap.entrySet()) {
            System.out.println("省份:"+map.getKey()+"，每市人口平均数："+map.getValue());
        }

        //=======================过滤================================

        //过滤获得人口数大于3000的城市
        List<City> collect = list.stream().filter(entity -> entity.getPopulation() > 3000).collect(Collectors.toList());
        System.out.println(JSONObject.toJSONString(collect));

        //map 获取list中实体的某个字段的集合
        List<String> map=list.stream().map(City::getCityName).collect(Collectors.toList());
        System.out.println("stream -> map :"+map);

        //===========================匹配===========================

        //全匹配，都符合条件的话返回true，否则返回false
        boolean allMatch = list.stream().allMatch(city -> city.getCityName().equals("榆林"));
        System.out.println("stream -> allMatch :"+allMatch);
        //部分匹配，只要有一个是的话返回true，全不是返回false
        boolean anyMatch = list.stream().anyMatch(city -> city.getCityName().equals("榆林"));
        System.out.println("stream -> anyMatch :"+anyMatch);
        //某字段的最大值
        City maxRankCity = list.stream().max(Comparator.comparing(City::getRank)).get();
        System.out.println("stream -> max :"+maxRankCity);
        City minRankCity = list.stream().min(Comparator.comparing(City::getRank)).get();
        System.out.println("stream -> min :"+minRankCity);

        //        reduce	归约，将流中元素反复结合起来得到一个值
        List<Integer> IntegerList = Arrays.asList(1,2,3,4,5,6);
        Integer reduce = IntegerList.stream().reduce(0, Integer::sum);
        System.out.println("stream -> reduce :"+reduce);

        //求和
        int sum = list.stream().filter(e->null != e.getPopulation()).mapToInt(City::getPopulation).sum();

        //根据城市字段名称去重
        Set<City> set = new TreeSet<>(Comparator.comparing(City::getCityName));
        set.addAll(list);
        list = new ArrayList<>(set);
        System.out.println(JSONObject.toJSONString(list));
    }

    private static void formData(List<City> list) {
        City city = new City("菏泽",2345,16,"山东");
        City city1 = new City("枣庄",2945,11,"山东");
        City city2 = new City("德州",8345,17,"山东");
        City city3 = new City("济南",8945,13,"山东");

        City city4 = new City("郑州",4670,18,"河南");
        City city5 = new City("开封",4550,21,"河南");
        City city6 = new City("洛阳",4580,27,"河南");
        City city7 = new City("新乡",4530,23,"河南");

        City city8 = new City("西安",2339,5,"陕西");
        City city9 = new City("渭南",2724,22,"陕西");
        City city10 = new City("宝鸡",3671,7,"陕西");
        City city11 = new City("榆林",4357,24,"陕西");
        list.add(city);
        list.add(city1);
        list.add(city2);
        list.add(city3);
        list.add(city4);
        list.add(city5);
        list.add(city6);
        list.add(city7);
        list.add(city8);
        list.add(city9);
        list.add(city10);
        list.add(city11);
    }