Stream流的深入理解与流式编程：

在今年年初小应学长也写过Stream与Lambda的两篇文章，今天先将两者结合起来进行流式编程

---

一、关于这两者

Stream与Lambda都是Java8引入的新概念，lambda在Java编程中对于函数式编程的支持，有助于代码的简洁，可以取代大半部分的匿名函数，尤其对于集合的遍历和集合的操作，极大的简化了代码。而Stream是使用函数式编程方式在集合类上进行操作的工具。

小结： 我们可以让Stream流使用lambda表达式来进行流式编程（让代码整洁、美观、高级感）

---

二、Lambda与Stream的结合使用

1、简单的筛选数据

一个实体类Person：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private Integer age;
    private String Sex;
}

这里可以使用Lombok的注解或者手动写get/set、构造方法

public class Test {

    private static final List<Person> personList = new ArrayList<>();

    static {
        personList.add(new Person("张三", 20, "男"));
        personList.add(new Person("李四", 25, "男"));
        personList.add(new Person("王五", 30, "男"));
        personList.add(new Person("小美", 18, "女"));
        personList.add(new Person("小红", 25, "女"));
    }

    //正常的for写法：找出年龄小于25岁的人
    public static void test01() {
        for (Person p : personList) {
            if (p.getAge()<25){
                //筛选后添加数据即可
            }
        }
    }
    
    //使用Stream流处理找出年龄小于25岁的人
    public static void test02() {
        List<Person> list = personList.stream().filter(p->p.getAge()<25).collect(Collectors.toList());
    }
}
    

上述代码中首先创建一个Person类，通过构造方法进行初始化并存入列表（模仿从数据库查询返回的数据），test01中用正常的for循环再对比，把符合条件的数据再进行处理。test02则使用stream来处理数据，加上Lambda的写法，最终就一行代码，这也就是流式编程。

多条件的查询：

    //年龄小于25岁且为性别为男的人
    public static void test02() {
        List<Person> list = personList.stream()
                .filter(p->p.getAge()<30)
                .filter(p->p.getSex().equals("男"))
                .collect(Collectors.toList());
    }

在stream后面多加filter即可

甚至还可以把条件放到外面进行传参的操作，比如这样：

   //年龄小于25岁且为性别为男的人
    public static void test03(Predicate<? super Person> p) {
        List<Person> list = personList.stream()
                .filter(p)
                .collect(Collectors.toList());
        System.out.println(list);
    }

    public static void main(String[] args) {
        test03(p->p.getAge()<25&&p.getSex().equals("男"));
    }

上述代码在main方法执行后，输出结果为[Person(name=张三, age=20, Sex=男)]，没问题

---

2、分组操作

对上面的列表数据进行按性别分组算平均年龄：
普通写法:

 public static void test04() {
        Map<String, List<Person>> map = new HashMap<>();
        for (Person p : personList) {
            //若当前性别没有分组（List），则new一个List
            List<Person> list = map.computeIfAbsent(p.getSex(), k -> new ArrayList<>());
            list.add(p);
        }
        for (Map.Entry<String, List<Person>> entry : map.entrySet()) {
            int agvAge = 0;
            for (Person person : entry.getValue()) {
                agvAge += person.getAge();
            }
            System.out.printf("平均年龄%s",agvAge/entry.getValue().size());
        }
    }

以往的普通步骤就是先循环List内每一个数据，然后通过get获取性别去判断是否等于男/女，然后存入对应Map，再去遍历这个Map，get到这个对象的年龄，通过累加然后除该Map的长度。

虽然上述代码有逻辑性、顺序，但是代码量多，用了三个for

使用Stream流的写法：

    public static void test05() {
        personList.stream().collect(Collectors.groupingBy(p -> p.getSex(),
                Collectors.averagingInt(p->p.getAge())))
                .forEach((k,v)-> System.out.println(k+":"+v));
    }
    //运行输出结果：女:21.5 男:25.0
    

OK 解决！
上述用到Stream内的方法：
groupingBy： 分组（和SQL里面个一样）
averagingInt： 对stream中的元素计算平均值

而且averaging可以操作不同的数据类型：

到这里我相信大家对Stream的功能以及Lambda的流式写法已经感觉很惊叹了，没事，我们继续！

---

三、Stream流的操作特性

1. 不储存数据（很好理解）
2. 不改变源数据（不管怎么操作，数据源不会改变）
3. 不可以重复使用（为什么不可以重复使用?）

关于特性，前面两个很好理解，但为什么不能重复使用的？

首先了解一下Stream流的执行机制，其实从名字上来看，流这个字就像水流一样，会顺着一个方向流，不能倒流或者回流，所以Stream流也是如此：

数据源的数据转成流后，先经过过滤，过滤完后会产生一个新的流，该流一旦使用完毕就会关闭。所以排序的操作是基于前者操作结束后产生的流，后者分组也是如此，
验证：

    public static void main(String[] args) {
        Stream<Person> s1 = personList.stream();
        Stream<Person> s2 = s1.filter(s -> s.getAge() < 25);
        Stream<Person> s3 = s1.filter(s -> s.getAge() < 15);
    }

依旧是上面的List转成流s1，然后首先过滤年龄<25的，然后再用s1的流去操作年龄<15的，但是运行就会报错：

stream has already been operated upon or closed
流已被操作或关闭

由此可见，一个流一旦操作结束，就会被关闭，所以在上述代码中要使用s2继续操作

---

通道内的节点：

上图

我们把在通道内过滤、排序、分组、分页、去重的操作称为中间节点（也称懒节点），意思是被加载进去后不会立马执行，遇到终值节点才会执行。

终值节点： 只能有一个，并且放最后

验证：

    public static void main(String[] args) {
        personList.stream().filter(p->{
            System.out.println("我是中间节点");
            return true;
        });
    }

filter为中间节点，若正确，则不会执行println语句，因为该语句内没有终值节点，不会被执行，运行后控制台果真没有输出值。

那么加上一个终值节点来看看效果，比如加上toArray():

    public static void main(String[] args) {
        personList.stream().filter(p->{
            System.out.println("我是中间节点");
            return true;
        }).toArray();
    }

运行后发现执行了println语句，控制台输出了内容！

如何快速分辨中间/终值节点：

我们只需要看结构即可，通过返回的类型来判断，一般返回为Stream的都为中间节点：

---

四、流执行的顺序

通过上面流的执行机制图可以看到数据源进入流的通道内开始处理数据，但数据并不是一次性进入通道的，比如List内有五个元素，也是依次进入通道处理，最后被采集到一起

验证：
还是上面的List，若数据是一次性传入的，下面代码会先输出所有的名字，再输出所有的年龄，如果名字和年龄是依次交替的输出，则说明该List是一个元素一个元素依次传入的
peek： 在流中消耗元素时对每个元素执行附加的操作

    public static void main(String[] args) {
        personList.stream()
                .peek(p-> System.out.println(p.getName()))
                .peek(p-> System.out.println(p.getAge()))
                .toArray();
    }

运行后，控制台结果为名字和年龄是依次交替的输出， 大家可以自行去试试鸭~

注意：peek也是中间节点，所以语句末尾要加上终值节点！

---

流内上下节点的影响性：

流的上一个节点会影响下一个节点，比如上述代码中，我们只要输出性别为男的数据：

    public static void main(String[] args) {
        personList.stream()
                .filter(p->p.getSex().equals("男"))
                .peek(p-> System.out.println(p.getName()+":"+p.getAge())).toArray();
    }

去重distinct()的影响:
为了在列表内有重复的数据，在上面List内添加一条一样的记录

personList.add(new Person("王五", 30, "男"));

然后执行以下代码：

    public static void main(String[] args) {
        personList.stream()
                .filter(p->p.getSex().equals("男"))
                .distinct()
                .peek(p-> System.out.println(p.getName()+":"+p.getAge())).toArray();
    }

先过滤性别是男的元素，然后进行去重操作

通过上图可以看到每个中间节点之间数据的变化，刚开始有6个元素，第一步filter后还剩4个，然后distinct，图中可以看到把最后两个数据合并成一个数据了，说明这两者是一样的，进行了去重，最后toArray()。

---

下期见~~~