java8新特性之StreamAPI

java8新特性——StreamAPI

---

1.什么是Stream流？

用于操作数据源（集合、数组等）所生成的元素序列。
集合讲的是数据，io流讲的是计算。

• Stream自己不会存储元素。
• Stream不会改变原对象，他们会返回一个持有结果的Stream的新流。
• Stream操作是延迟执行的，他们要等到需要结果的时候才会执行，

2.创建Stream流的步骤

1.创建Stream
一个数据源获取一个流（数据源：集合、数组）
2.中间操作(不会执行任何操作)
一个中间操作链，对数据源的数据做处理。
3.终止操作（一次性全部执行并输出结果）
一个终止操作，执行中间操作，并产生结果

3.创建Stream

1.可以通过Collection系列集合提供的Stream（）或者pallelStream（）
2.通过Arrays中的静态方法stream()获取数组流
3.通过Stream类中的静态of()方法

 @Test
    public void test1(){
        //1.可以通过Collection系列集合提供的Stream（）或者pallelStream
        List<String> list=new ArrayList<>();
        Stream<String> stream = list.stream();
        //2.通过Arrays中的静态方法stream()获取数组流
        User[] users = new User[10];
        Stream<User> stream1 = Arrays.stream(users);
        //3.通过Stream类中的静态of()方法
        Stream<String> stringStream = Stream.of("test","xiong","luo");
        //4.创建无限流
        //迭代
        Stream<Integer> iterate = Stream.iterate(0, (x) -> x + 2);
        iterate
                .limit(10) //中间操作
                .filter(x->x%2==0)//中间操作
                .forEach(System.out::println);//终止操作

    }

4.中间操作

1.filter-接收Lambda，从流中排除某些元素（过滤某些元素）
2.limit-截断流，使其元素不超过给定数量
3.skip(n)-跳过元素，返回一个扔掉前n个元素的流，若流中不足n个元素，返回一个空流，与limit(n)互补
4.distinct-筛选，通过流所生成元素的hashCode()和equals()去除重复元素

   List<User> users=Arrays.asList(
            new User("小白",23,10000),
            new User("小黑",35,9000.0),
            new User("小黄",29,5000),
            new User("小花",49,15000),
            new User("小花",49,15000)
    );


/**
     * 筛选与切片
     * filter-接收Lambda，从流中排除某些元素（过滤某些元素）
     * limit-截断流，使其元素不超过给定数量
     * skip(n)-跳过元素，返回一个扔掉前n个元素的流，若流中不足n个元素，返回一个空流，与limit(n)互补
     * distinct-筛选，通过流所生成元素的hashCode()和equals()去除重复元素
     * */
    @Test
    public void test2(){
        users
                .stream()
                .filter(user -> user.getAge()>30)
                .forEach(System.out::println);
        users
                .stream()
                .filter(user -> user.getAge()>30)//过滤出数据
                .skip(1)//扔掉最前面一条
                .forEach(System.out::println);
        //去重
        users.stream().distinct().forEach(System.out::println);
    }

1.map-接收lambda,将元素转换为其他形式或提取信息，接收一个函数作为参数，该函数会被应用到每个元素上，将其映射为一个新的元素
2.flatMap-接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流都换成一个流

    /**
     * 1.map-接收lambda,将元素转换为其他形式或提取信息，接收一个函数作为参数，该函数会被应用到每个元素上，将其映射为一个新的元素
     * 2.flatMap-接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流都换成一个流
     * */
    @Test
    public void  test3(){
        List<String> list = Arrays.asList("luo", "she", "he", "man");
        list.stream().map(x->x.toUpperCase()).forEach(System.out::println);
        users.stream()
                .map(x->x.getName())
                .forEach(System.out::println);

    }

//
//Map 
    @Test
    public void  test3(){
        //过滤出每个字符
        Stream<Stream<Character>> streamStream = list
                .stream()
                .map(StreamAPI::filterCharacter);//StreamAPI类名 {{l,u,o},{s,h,e}.......}
        streamStream.forEach(x->{
            x.forEach(System.out::println);
        });
    }
    public static Stream<Character> filterCharacter(String str){
        List<Character> list=new ArrayList<>();
        for (Character c:str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }
//
//flatMap
  Stream<Character> characterStream1 = list
                .stream()
                .flatMap(StreamAPI::filterCharacter);//{l,u,o,s,h,e........}
        characterStream1.forEach(System.out::println);

    /**
     * map和flatmap和稽核中的add(Object o)和addAll(Collection coll)类似
     * */
    @Test
    public void  test4(){
        List<String> list = Arrays.asList("luo", "she", "he", "man");
        List<Object> string = new ArrayList<>();
        string.add("bear");
        string.add(list);
        System.out.println(string);//[bear, [luo, she, he, man]]
    }

   @Test
    public void  test4(){
        List<String> list = Arrays.asList("luo", "she", "he", "man");
        List<Object> string = new ArrayList<>();
        string.add("bear");
        //string.add(list);
        string.addAll(list);
        //System.out.println(string);//[bear, [luo, she, he, man]]
        System.out.println(string);//[bear, luo, she, he, man]
    }

排序
sorted()-自然排序
sorted(Comparator com)-定制排序

 /**
     * 排序
     * sorted()-自然排序(Comparable)
     * sorted(Comparator com)-定制排序(Comparator)
     * */
    @Test
    public void  test5(){
        List<String> list = Arrays.asList("ddd", "aaa", "ccc", "bbb");
        list
                .stream()
                .sorted()
                .forEach(System.out::println);
        users.stream()
                .sorted((u1,u2)->{
                    if (u1.getAge().equals(u2.getAge())){
                        return u1.getName().compareTo(u2.getName());
                    }else {
                        return u1.getAge().compareTo(u2.getAge());
                    }
                }).forEach(System.out::println);
    }

5.终止操作

查找与匹配
allMatch-检查是否匹配所有元素
anyMatch-检查是否至少匹配一个元素
noneMatch-检查是否没有匹配所有元素
findFirst-返回第一个元素
findAny-返回当前流中的任意元素
count-返回流中元素的总个数
max-返回流中的最大值
min-返回流中最小值

    /**
     * 查找与匹配
     * allMatch-检查是否匹配所有元素
     * anyMatch-检查是否至少匹配一个元素
     * noneMatch-检查是否没有匹配所有元素
     * findFirst-返回第一个元素
     * findAny-返回当前流中的任意元素
     * count-返回流中元素的总个数
     * max-返回流中的最大值
     * min-返回流中最小值
     */
    @Test
    public void test6() {
        //是否匹配所有元素
        boolean b = users.stream().allMatch(x -> x.getAge() > 25);
        System.out.println(b);
        //是否至少匹配一个元素
        boolean b1 = users.stream().anyMatch(x -> x.getMoney() > 100000);
        //是否没有匹配所有元素
        boolean luo = users.stream().noneMatch(s -> s.getAge().equals("小白"));
        //返回第一个元素
        Optional<User> first = users
                .stream()
                .sorted((e1, e2) -> -Double.compare(e1.getMoney(), e2.getMoney()))//负号表示找最大的工资
                .findFirst();
        System.out.println(first.get());
        //返回当前流中的任意元素
        Optional<User> any = users.stream().filter(x -> x.getMoney() > 100000).findAny();
        System.out.println(any.get());
        //返回流中元素的总个数
        long count = users.stream().count();
        System.out.println(count);
        //返回流中的最大值
        Optional<User> max = users.stream().max((e1, e2) -> Double.compare(e1.getMoney(), e2.getMoney()));
        System.out.println(max.get());
        //返回流中的最小值
        Optional<User> min = users.stream().min((e1, e2) -> Double.compare(e1.getMoney(), e2.getMoney()));
        System.out.println(max.get());
    }

归约
reduce（T identity，BinaryOperator b）-可以将流中元素结合起来得到一个值

 /**
     * 归约
     * reduce（T identity，BinaryOperator  b）-可以将流中元素结合起来得到一个值
     * */
    @Test
    public void test7() {
        //累加操作
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
        Integer reduce = integers.stream().reduce(0,(x, y) -> x + y);//从0开始
        System.out.println(reduce);//15
        
         //获取所有钱
        Optional<Double> reduce1 = users.stream().map(User::getMoney).reduce(Double::sum);
        System.out.println(reduce1.get());
    }

收集
collect-将流转换为其他的形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

/**
 *collect-将流转换为其他的形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
 * */
@Test
public void test8() {
    //转化为List
    List<Double> money = users.stream().map(User::getMoney).collect(Collectors.toList());
    //转化为set集合
    Set<String> name = users.stream().map(User::getName).collect(Collectors.toSet());
    //转化为HashSet
    HashSet<Integer> age = users.stream().map(User::getAge).collect(Collectors.toCollection(HashSet::new));
    //总数
    Long sum = users.stream().collect(Collectors.counting());
    //平均值
    Double averageMoney = users.stream().collect(Collectors.averagingDouble(User::getMoney));
    //总和
    DoubleSummaryStatistics totalMoney = users.stream().collect(Collectors.summarizingDouble(User::getMoney));
    //最大值
    Optional<User> max = users.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getMoney(), e2.getMoney())));
    System.out.println(max.get().getMoney());
    //最小值
    Optional<User> min = users.stream().collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getMoney(), e2.getMoney())));
    System.out.println(min.get().getMoney());
    //分组(单一)
    Map<Integer, List<User>> group = users.stream().collect(Collectors.groupingBy(User::getAge));
    //分组(多级分组)
    Map<Integer, Map<String, List<User>>> collect = users
            .stream()
            .collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy((user)->{
                if (user.getMoney()>10000){
                    return "富人";
                }else {
                    return "穷人";
                }
            })));
    System.out.println(collect);
    //分区（按照某一个值分区处理,满足条件的为true，不满足条件的为false）
    Map<Boolean, List<User>> partitioning = users.stream().collect(Collectors.partitioningBy((e) -> e.getAge() > 30));
    System.out.println(partitioning);
    /
    DoubleSummaryStatistics summarizing = users.stream().collect(Collectors.summarizingDouble(User::getMoney));
    summarizing.getAverage();//平均值
    summarizing.getCount();//总数
    summarizing.getMax();//最大值
    summarizing.getMin();//最小值
    summarizing.getSum();//总和

    //连接字符转(根据逗号分隔)
    String nameStr = users.stream()
            .map(User::getName)
            .collect(Collectors.joining(","));
    System.out.println(nameStr);

}