Stream_Java8

：：：：：：：：：：：：间隔长时间的回顾总结：：：：：：：：：：：：
此篇文章 只用做自己笔记积累总结，不做任何商业用途，不收任何费用，不喜勿喷，欢迎指导

介绍

A sequence of elements supporting sequential and parallel aggregate
operations.【支持顺序和并行聚合操作的元素序列。】

集合转换为叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator，进行流化处理之后，再进行流的汇聚，输出相应的处理结果集合。

构成

1. 创建流

1. Stream静态工厂方法

1、Stream.of，传入一个泛型数组，或者多个参数，创建一个流
2、Stream.iterate，这个静态方法，是以迭代器的形式，创建一个数据流
3、Stream.generate

2. Collection

1、Arrays.stream，我们可以通过Arrays的静态方法，传入一个泛型数组，创建一个流
2、Collection.stream,可以用过集合的接口的默认方法，创建一个流；使用这个方法，包括继承Collection的接口，如：Set，List，Map，SortedSet 等等

2. 转换流
3. 汇总输出流reduce：

使用

流化处理分两种： stream() 串行流、 parallelStream()并行流
当使用串行方式去遍历时，每个 item 读完后再读下一个 item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。
以下代码包含流的基础使用：

@Data
@Builder
public class User {
    private String name;
    private Integer age;
}

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toList;

/**
 * @author: Guoxy
 * @create: 2021-06-26 14:59
 **/
public class a {

    public static void main(String[] args) {
        User user = User.builder().age(10).name("张三").build();
        User user1 = User.builder().age(20).name("李四").build();
        User user2 = User.builder().age(30).name("王五").build();
        User user3 = User.builder().age(30).name("Guoxy").build();
        List<User> list = CollUtil.newArrayList(user,user1,user2,user3);

        List<User> userListData = list.stream().filter(userList -> userList.getAge().equals(10)).collect(toList());
        userListData.forEach(k ->{
            System.out.println(k.getName());//张三
        });

        List<Integer> ageList = list.parallelStream().map(User::getAge).distinct().sorted().limit(2).skip(1).collect(toList());
        List<String> nameList = list.parallelStream().map(User::getName).collect(toList());
        ageList.forEach(age -> System.out.println(age));//20【去重】
        nameList.forEach(name -> System.out.println(name));//张三 李四 王五 Guoxy
		nameList.stream().forEach(System.out::println);
        Map<String,User> nameMap = CollUtil.newHashMap(4);
        nameMap = list.parallelStream().collect(Collectors.toMap(User::getName,obj -> obj));
        nameMap.entrySet().parallelStream().forEach(map -> System.out.println(map));
        /**
         * Guoxy=User(name=Guoxy, age=30)
         * 李四=User(name=李四, age=20)
         * 张三=User(name=张三, age=10)
         * 王五=User(name=王五, age=30)
         * */

        Map<String,User> map = nameMap.entrySet().parallelStream()
                .filter(k -> StrUtil.equals("Guoxy",k.getKey()))
                .collect(Collectors.toMap(p -> p.getKey(),p->p.getValue()));

        map.entrySet().forEach(obj -> System.out.println(obj));
        //Guoxy=User(name=Guoxy, age=30)

        List<User> filterList = nameMap.entrySet().parallelStream()
                .filter(k -> StrUtil.equals("Guoxy",k.getKey())).map(k -> k.getValue()).collect(toList());

        filterList.forEach(obj -> System.out.println(obj));
        //User(name=Guoxy, age=30)

 int sum = list.stream().map(User::getAge).reduce(0, (a, b) -> a + b);
        int suma = list.stream().map(User::getAge).reduce(0, Integer::sum);
        System.out.println(sum+"="+suma);//90=90
        
  int sumb = list.stream().map(User::getAge).reduce(1, (a, b) -> a * b);
        System.out.println(sumb);//180000
Optional<Integer> sumaa = list.stream().map(User::getAge).reduce(Integer::sum);



    }
}

filter()：满足过滤条件的保留，其他被过滤掉
collect(toList()) ：把流转换为 List 类型
distinct()：去除重复元素，这个方法是通过类的 equals 方法来判断两个元素是否相等的，例子中的 User类，需要先定义好 equals 方法
sorted() ：如果流中的元素的类实现了 Comparable 接口，即有自己的排序规则，那么可以直接调用 sorted() 方法对元素进行排序，如 Stream
反之, 需要调用 sorted((T, T) -> int) 实现 Comparator 接口
limit(long n)：返回前 n 个元素
skip(long n)：去除前 n 个元素
map()：将流中的每一个元素 映射为map类型的值（类似类型转换）
flatMap：将流中的每一个元素映射为一个流，再把每一个流连接成为一个流
anyMatch：流中是否有一个元素匹配给定的对象满足true条件
boolean b = list.stream().anyMatch(user-> user.getAge() == 20);
allMatch：流中是否所有元素都匹配
noneMatch：流中是否没有元素匹配
findAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream() 并行时找到的是其中一个元素）
findFirst()：找到第一个元素
reduce：用于组合流中的元素，如求和，求积，求最大值等
count()： 返回流中元素个数，结果为 long 类型
collect()： 收集方法 collect(toList())， collect(toSet())
forEach()：遍历

感谢https://blog.csdn.net/a13662080711/article/details/84928181，学习到了很多！！！！！
附一个Java流相关http://www.mstacks.com/107/742.html#content742