JDK8新特性之 stream(）

package kgc_byme.day19.tets.tes_map;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @Description: TODO
 * @author: azzhu
 * @date:2021/6/4 10:09
 */
public class TestStream1 {
    public static void main(String[] args) {
        ArrayList<Stu> stus  = new ArrayList<>();
        stus.add(new Stu("张三","135456",89));
        stus.add(new Stu("李三","136456",95));
        stus.add(new Stu("张四","137456",97));
        stus.add(new Stu("王三","138456",78));
        stus.add(new Stu("王三","138456",78));




        //todo 统计上面集合中score的最大、最小、平均、总分
//        int max = stus.get(0).score;
//        for (Stu stu : stus) {
//            if(stu.name.startsWith("张") && stu.score > max) {
//                max = stu.score;
//            }
//        }
//        System.out.println(max);
        //1.将集合转换成Stream
        //stus.stream().max((o1,o2) -> o1.score - o2.score);
        //max():获取最大值对应的学生信息
       // Optional<Stu> optional = stus.stream().max(Comparator.comparingInt(o -> o.score));

        //获取最大的分数：等效于我们上面的那个求最大分数
        //map:变化结果，里面的参数是一个Function函数式接口，在scala、spark、flink中均有，而且经常会使用！！
//        Optional<Integer> max = stus.stream()
//                .map(stu -> stu.score)
//                .max((o1, o2) -> o1 - o2);
//        System.out.println(max.get());
        // System.out.println(optional.get());

        //获取名字包含三，按照分数降序排列，只获取top2
        //filter:过滤，里面是一个Predict预测型接口
        //limit():获取前几个
//        List<Stu> filterList = stus.stream()
//                .filter(stu -> stu.name.contains("三"))
//                .sorted(Comparator.comparingInt(o -> -o.score))
//                .limit(2)
//                //.forEach(System.out::println);
//                .collect(Collectors.toList());

        //一次性拿到统计信息
//        IntSummaryStatistics summaryStatistics = stus.stream().mapToInt(stu -> stu.score)
//                .map(score -> score + 2)
//                .summaryStatistics();
//
//        System.out.println(summaryStatistics.getMax());
//        System.out.println(summaryStatistics.getAverage());
//        System.out.println(summaryStatistics.getSum());
//        System.out.println(summaryStatistics.getCount());
//        System.out.println(summaryStatistics.getMin());

        //去重:distinct,我们自己的类要重写equals才能实现去重
        //forEachOrdered 尝试重写了两个比较的接口都不行
       // stus.stream().distinct().forEachOrdered(stu -> System.out.println(stu));
      //  stus.stream().distinct().forEachOrdered(System.out::println);

//        stus.stream().distinct().forEachOrdered(System.out::println);
//        System.out.println("============");

        //reduce：聚合，使用reduce聚合上面的分数，在后面也是经常用到
        //sum()可以累加



//        System.out.println(stus.stream().mapToInt(stu -> stu.score)
//                .sum());

//        System.out.println(stus.stream().mapToInt(stu -> stu.score)
//                .sum());

//        OptionalInt sum = stus.stream().mapToInt(stu -> stu.score).reduce((x1, x2) -> x1 + x2);

//        OptionalInt sum = stus.stream().mapToInt(stu -> stu.score).reduce((x1, x2) -> x1 + x2);
//        int sum = stus.stream().mapToInt(stu -> stu.score).reduce(20, Integer::sum);
//        System.out.println(sum);


        // int sum = stus.stream().mapToInt(stu -> stu.score).reduce(20, (x1, x2) -> x1 + x2);
        //三参：①参给定一个初始化值，②参：累加器，进行聚合；③combiner合并

//        Integer sum = stus.stream().map(stu -> stu.score).reduce(20, (x1, x2) -> x1 + x2, (res1, res2) -> res1 + res2);
//        System.out.println("---------------");
//        System.out.println(stus.stream().map(stu -> stu.score).reduce(20, Integer::sum, Integer::sum));
//        System.out.println(stus.stream().map(stu -> stu.score).reduce(20, (x1, x2) -> x1 + x2, (res1, res2) -> res1 + res2));


//        System.out.println(sum);
        System.out.println(stus.stream().count());

        //对如下的信息做wc词频统计   [[Jordan], [Kobe, James], [James, Curry]]  List<String>

//        List<List<String>> words = Arrays.asList(Arrays.asList("Jordan"),
//                Arrays.asList("Kobe","James"),Arrays.asList("James","Curry")
//        );
        List<List<String>> lists = Arrays.asList(Arrays.asList("josh"), Arrays.asList("kjsa", "sasad"), Arrays.asList("nige", "sasad"));

        System.out.println(lists);
        //1 -> n
//        List<String> resultList = words.stream()
//                .flatMap(list -> list.stream().map(t -> t+ t))
//                .collect(Collectors.toList());
        List<String> resultList = lists.stream().flatMap(list -> list.stream().map(t -> t ))
                .collect(Collectors.toList());

        System.out.println(resultList);
    resultList.stream().collect(Collectors.groupingBy((str->str)))
            .forEach((word,list)->{
                System.out.println(word+">>>>"+list.size());
            });
//        .forEach( t-> System.out.println(t));




        //[Jordan, Kobe, James, James, Curry]  ---> 可以分组   James, James 放入到集合中 List list.size
        //定义一个类WC，word,count,  new WC(Jordan,1)  ----> 用分组，结合reduce搞定
//        System.out.println(resultList);
//        resultList.stream().collect(Collectors.groupingBy(str -> str))
//                .forEach((word,list) -> {
//                    System.out.println(word + ">>>>" + list.size());
//                });
        // .forEach(t -> System.out.println(t));

        Map<String,Stu> map = new HashMap<>(); //收集来的结果为Map<String,name>
        map.put("1001",new Stu("张三","135456",89));
        map.put("1002",new Stu("李三","136456",95));
        map.put("1003",new Stu("张四","137456",97));
        map.put("1004",new Stu("王三","138456",78));
        map.put("1005",new Stu("王三","138456",78));

//        map.entrySet().stream().map( entry->entry.getKey()+" "+entry.getValue())
//                .forEach(System.out::println);

//        map.entrySet().stream().map(entry -> entry.getKey()+","+entry.getValue().name)
//                .forEach(t -> System.out.println(t));
//        Map<String, String> result2 = map.entrySet()
//                .stream()
//                .collect(Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().name));
//        System.out.println(result2);



        Map<String, String> result = map.entrySet()
                .stream()
                .collect(Collectors.toMap(entry -> entry.getKey(), entry -> entry.getValue().name));
        System.out.println(result);

    }
}

class Stu implements Comparator<Stu>{
    String name;
    String phoneNo;
    int score;   //做一些数据统计，

    public Stu(String name, String phoneNo, int score) {
        this.name = name;
        this.phoneNo = phoneNo;
        this.score = score;
    }

    public Stu() {
    }

    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", phoneNo='" + phoneNo + '\'' +
                ", score='" + score + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Stu stu = (Stu) o;
        return score == stu.score && Objects.equals(name, stu.name) && Objects.equals(phoneNo, stu.phoneNo);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, phoneNo, score);
    }

    @Override
    public int compare(Stu o1, Stu o2) {
        return o1.score - o2.score;
    }
}