一什么是Stream？

流是Java8引入的全新概念，它用来处理集合中的数据，暂且可以把它理解为一种高级集合。

众所周知，集合操作非常麻烦，若要对集合进行筛选、投影，需要写大量的代码，而流是以声明的形式操作集合，它就像SQL语句，我们只需告诉流需要对集合进行什么操作，它就会自动进行操作，并将执行结果交给你，无需我们自己手写代码。

因此，流的集合操作对我们来说是透明的，我们只需向流下达命令，它就会自动把我们想要的结果给我们。由于操作过程完全由Java处理，因此它可以根据当前硬件环境选择最优的方法处理，我们也无需编写复杂又容易出错的多线程代码了。

需要注意的：

1、Stream自身不存储元素

2、Steam不改变源对象，会返回一个持有结果的新Stream

3、Stream操作是延迟执行的。会等到需要结果的时候才开始执行

二流的执行步骤：

1、创建Stream：一个数据源，获取一个流

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

3、终止操作（终端操作）：一个终止操作，执行中间操作链，并产生结果

三创建Stream

1、Java8中Collection接口被扩展，提供两种获取流的方法 stream() 返回一个顺序流；parallelStream()返回一个并行流

2、Arrays中静态方法stream()获取数组流

3、通过stream类中的静态方法of()

4、通过stream类中静态方法iterate()和generate()创建无限流

//     1、可以通过Collection系列集合提供的stream()或parallelStream（）（并行流）
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
//        parallelStream（）（并行流）
        Stream<String> parallelStream = list.parallelStream();
 
//        2、通过Arrays中静态方法stream（）获取数组流
        Employess[] emps = new Employess[10];
        Stream<Employess> stream2 = Arrays.stream(emps);
 
//        3、通过stream类中的静态方法of（）
        Stream<String> stream3 = Stream.of("aa", "bb", "cc");
 
//        4、创建无限流
//        迭代
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2).limit(10);
//        生成
        Stream.generate(() -> Math.random()).limit(5);

并行流是把内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

Java8 中将并行进行优化，通过stream API使用parallel和sequential（）在并行流和顺序流中切换

四 stream流的方法使用

1 筛选与切片

在这里插入图片描述

如:

//filter函数接收一个Lambda表达式作为参数，该表达式返回boolean，在执行过程中，流将元素逐一输送给filter，并筛选出执行结果为true的元素。如，筛选出所有学生：

List<User> result = list.stream().filter(User::isStudent).collect(toList());


//去掉重复的结果：

List<Person> result = list.stream().distinct().collect(toList());

//截取流的前N个元素：

List<Person> result = list.stream().limit(3).collect(toList());

//跳过流的前n个元素:

List<Person> result = list.stream().skip(3).collect(toList());

//

2 映射

在这里插入图片描述

如：

//对流中的每个元素执行一个函数，使得元素转换成另一种类型输出。
//流会将每一个元素输送给map函数，并执行map中的Lambda表达式，最后将执行结果存入一个新的流中。
//如，获取每个人的姓名(实则是将Perosn类型转换成String类型)：

List<User> result = list.stream().map(User::getName).collect(toList());

合并多个流：列出List中各不相同的单词，List集合如下

//列出List中各不相同的单词，List集合如下

List<String> list = new ArrayList<String>();
list.add("I am a boy");
list.add("I love the girl");
list.add("But the girl loves another girl");

//首先将list变成流：
list.stream();

//按空格分词
list.stream().map(line->line.split(" "));

//分完词之后，每个元素变成了一个String[]数组。将每个String[]变成流：

list.stream().map(line->line.split(" ")).map(Arrays::stream)


//此时一个大流里面包含了一个个小流，我们需要将这些小流合并成一个流。

// 将小流合并成一个大流：用flagmap替换刚才的map

list.stream().map(line->line.split(" ")).flagmap(Arrays::stream)

//去重

list.stream()
            .map(line->line.split(" "))
            .flagmap(Arrays::stream)
            .distinct()
            .collect(toList());

3 Stream的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的
值，例如： List、 Integer，甚至是 void 。

查找与匹配：

在这里插入图片描述

// 是否匹配任一元素：anyMatch 如，判断list中是否有学生：
//anyMatch用于判断流中是否存在至少一个元素满足指定的条件，这个判断条件通过Lambda表达式传递给anyMatch，执行结果为boolean类型。

boolean result = list.stream().anyMatch(Person::isStudent);

// 是否匹配所有元素：allMatch 判断是否所有人都是学生：
// allMatch用于判断流中的所有元素是否都满足指定条件，这个判断条件通过Lambda表达式传递给anyMatch，执行结果为boolean类型。

boolean result = list.stream().allMatch(Person::isStudent);

//是否未匹配所有元素：noneMatch
// noneMatch与allMatch恰恰相反，它用于判断流中的所有元素是否都不满足指定条件：

boolean result = list.stream().noneMatch(Person::isStudent);

//获取任一元素findAny
//findAny能够从流中随便选一个元素出来，它返回一个Optional类型的元素

Optional<Person> person = list.stream().findAny();

// 获取第一个元素findFirst 
Optional<Person> person = list.stream().findFirst();

//Optional介绍
Optional是Java8新加入的一个容器，这个容器只存1个或0个元素，它用于防止出现NullpointException，它提供如下方法：

//isPresent()
判断容器中是否有值。
//ifPresent(Consume lambda)
容器若不为空则执行括号中的Lambda表达式。
//T get()
获取容器中的元素，若容器为空则抛出NoSuchElement异常。
//T orElse(T other)
获取容器中的元素，若容器为空则返回括号中的默认值。

归约：

流由一个个元素组成，归约就是将一个个元素“折叠”成一个值，如求和、求最值、求平均值都是归约操作。

归约是将集合中的所有元素经过指定运算，折叠成一个元素输出，如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出。

在流中，reduce函数能实现归约。
reduce函数接收两个参数：

初始值
进行归约操作的Lambda表达式

如：元素求和：自定义Lambda表达式实现求和例：计算所有人的年龄总和

// 元素求和：自定义Lambda表达式实现求和 例：计算所有人的年龄总和

int age = list.stream().reduce(0, (person1,person2)->person1.getAge()+person2.getAge());

//reduce的第一个参数表示初试值为0；
//reduce的第二个参数为需要进行的归约操作，它接收一个拥有两个参数的Lambda表达式，reduce会把流中的元素两两输给Lambda表达式，最后将计算出累加之和。

元素求和：使用Integer.sum函数求和

//上面的方法中我们自己定义了Lambda表达式实现求和运算，如果当前流的元素为数值类型，那么可以使用Integer提供了sum函数代替自定义的Lambda表达式，如：

int age = list.stream().reduce(0, Integer::sum);

Integer类还提供了min、max等一系列数值操作，当流中元素为数值类型时可以直接使用。

数值流的使用

采用reduce进行数值操作会涉及到基本数值类型和引用数值类型之间的装箱、拆箱操作，因此效率较低。
当流操作为纯数值操作时，使用数值流能获得较高的效率。

将普通流转换成数值流

// StreamAPI提供了三种数值流：IntStream、DoubleStream、LongStream，也提供了将普通流转换成数值流的三种方法：mapToInt、mapToDouble、mapToLong。
// 如，将User中的age转换成数值流：

 IntStream stream = list.stream().mapToInt(User::getAge);

数值计算

// 每种数值流都提供了数值计算函数，如max、min、sum等。
// 如，找出最大的年龄：

OptionalInt maxAge = list.stream().mapToInt(Person::getAge).max();

由于数值流可能为空，并且给空的数值流计算最大值是没有意义的，因此max函数返回OptionalInt，它是Optional的一个子类，能够判断流是否为空，并对流为空的情况作相应的处理。
此外，mapToInt、mapToDouble、mapToLong进行数值操作后的返回结果分别为：OptionalInt、OptionalDouble、OptionalLong