Stream流式编程

Stream：就是数据渠道，用于操作数据源（集合、数组）所产生的元素序列。“集合讲的是数据，流讲的是计算。”是JDK1.8的新特性。

注意：

1.Stream 自己不会存储元素。

2.Stream 不会改变源对象。相反，他们会返回一个持有结果的新的Stream。

3.Stream 操作时延迟执行的。这意味着他们会等到需要的结果的时候才会执行。

Stream操作的三个步骤

1.创建Stream

一个数据源（如：集合、数组），获取一个流

2.中间操作

一个中间操作链，对数据源的数据进行处理

3.终止操作（终端操作）

一个终止操作，执行中间操作链，并产生结果。

Stream流常用的API：

filter：过滤   map：映射，举例：将一个对象集合 映射 只获取ID集合     sorted：排序       sum：求和，求最大值，最小值等一些聚合操作的函数       groupingBy:分组    limit:截取，可以实现分页效果      distinct：去重

当然在使用toMap()函数之后，返回的就是一个Map了，自然会需要key和value。toMap()的第一个参数就是用来生成key值的，第二个参数就是用来生成value值的。第三个参数用在key值冲突的情况下：如果新元素产生的key在Map中已经出现过了，第三个参数就会定义解决的办法。

 

下面是我自己写的一个小demo，实体类可以下载个lombok这个插件，通过注解@Data来完成get，set的构建。

1、创建一个User的实体类

public class User {
     private String name;
    private   int age;

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

    public User() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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


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

2、写一个main方法

package org.example;

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

public class Main {
    public static void main(String[] args) {
        ArrayList<User> objects = new ArrayList<>();
        objects.add(new User("张三",21));
        objects.add(new User("张三1",31));
        objects.add(new User("张三2",41));
        objects.add(new User("张三3",11));
        objects.add(new User("张三4",21));
//         System.out.println(objects);
//         stream流的使用

        System.out.println("循环输出===============================");
//        1、循环输出   foreach
        objects.stream().forEach(lx->{
            System.out.println(lx);
        });
        /**
         * User{name='张三', age=21}
         * User{name='张三1', age=31}
         * User{name='张三2', age=41}
         * User{name='张三3', age=11}
         * User{name='张三4', age=21}
         */


        System.out.println("过滤个数===============================");
//        2、过滤  filter
        long count = objects.stream().filter(l -> 0!= l.getAge()).count();
        System.out.println("年龄不等于0的个数："+count);
        /**
         * 年龄不等于0的个数：5
         */

        List<User> collect = objects.stream().filter(l -> l.getAge() > 21).collect(Collectors.toList());
        System.out.println("年龄大于21的："+collect);
        /**
         * 年龄大于21的：[User{name='张三1', age=31}, User{name='张三2', age=41}]
         */

        List<User> collect1 = objects.stream().filter(l -> l.getAge()!=0).collect(Collectors.toList());
        System.out.println("成绩不为0的："+collect1);
        /**
         * 成绩不为0的：[User{name='张三', age=21}, User{name='张三1', age=31}, User{name='张三2', age=41}, User{name='张三3', age=11}, User{name='张三4', age=21}]
         */

        List<User> collect2= objects.stream().filter(l -> l.getAge() !=0).sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
        System.out.println("按照最高排序："+collect2);
        /**
         * 按照最高排序：[User{name='张三2', age=41}, User{name='张三1', age=31}, User{name='张三', age=21}, User{name='张三4', age=21}, User{name='张三3', age=11}]
         */

//        3、map集合映射
        System.out.println("map集合映射===============================");
        String collect3 = objects.stream().map(l -> l.getName()).collect(Collectors.joining("、"));
        System.out.println("所有名字以拼接字符串的方式连接在一起（顿号分割）："+collect3);
        /**
         * 所有名字以拼接字符串的方式连接在一起（顿号分割）：张三、张三1、张三2、张三3、张三4
         */

        Map<Integer, List<User>> collect4 = objects.stream().filter(l -> l.getAge() != 0).collect(Collectors.groupingBy(User::getAge));
        System.out.println("按照年龄进行归类："+collect4);
        /**
         * 按照年龄进行归类：
         * {21=[User{name='张三', age=21}, User{name='张三4', age=21}],
         * 41=[User{name='张三2', age=41}],
         * 11=[User{name='张三3', age=11}],
         * 31=[User{name='张三1', age=31}]}
         */

//      遍历map，取出内容
        for(Map.Entry<Integer,List<User>> listMap:collect4.entrySet()){
            System.out.println("年龄为："+listMap.getKey()+"的数量"+listMap.getValue().size()+"人----"+listMap.getValue());
        }
        /**
         * 年龄为：21的数量2人----[User{name='张三', age=21}, User{name='张三4', age=21}]
         * 年龄为：41的数量1人----[User{name='张三2', age=41}]
         * 年龄为：11的数量1人----[User{name='张三3', age=11}]
         * 年龄为：31的数量1人----[User{name='张三1', age=31}]
         */

        System.out.println("Statistics进行统计===============================");
//      3、Statistics进行统计
        IntSummaryStatistics intSummaryStatistics = objects.stream().mapToInt(l -> l.getAge()).summaryStatistics();
        System.out.println("年龄最大的："+intSummaryStatistics.getMax());
        System.out.println("年龄最小的："+intSummaryStatistics.getMin());
        /**
         * 年龄最大的：41
         * 年龄最小的：11
         */
    }



}