Stream流
- 说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。
- 当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。
- 诸如
filter、map、skip都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法 类似于count,forEach执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。就相当于现将流水线硬件先建立好，然后再启动流水线！
“Stream流”其实是一个集合元素的函数模型(处理的步骤方法)，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。
Stream（流）是一个来自数据源的元素队列
- 元素是特定类型的对象，形成一个队列，Java中的Stream并不会存储元素，而是按需计算。
- 数据源流的来源，可以使集合、数组等。
和以前的Collection操作不同， Stream操作还有两个基础的特征
- Pipelining:中间操作都会返回流对象本身。这样多个操作可以串联成一个管道， 如同流式风格（
fluentstyle）。这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting) - 内部迭代：以前对集合遍历都是通过
Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。Stream提供了内部迭代的方式，流可以直接调用遍历方法。
通常使用流的三个基本步骤
- 获取一个数据源(Source)
- 数据转换
- 执行操作获取险要的结果
每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道
一、获取流
java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。【这并不是一个函数式接口。】，获取流有一下几种方式
- 所有的
Collection集合都可以通过stream默认方法获取流 Stream接口的静态方法of可以获取数组对应的流
1.根据Collection获取流
java.util.Collection 接口中加入了默认方法default stream 用来获取流，所以其所有实现类均可获取流
List<String> list = new ArrayList<>();
Stream<String> st1 = list.stream();
Set<String> set = new HashSet<>();
Stream<String> st2 = set.stream();
Vector<String> vector = new Vector<>();
Stream<String> st3 = vector.stream();
2.根据Map获取流
java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况
Map<String,String> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream();
Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String,String>> entryStream = map.entrySet().stream();
3.根据数组获取流
如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream接口中提供了静态方法of ，使用很简单
of方法的签名是可变长参数
String[] array = {"张三","李四","王二","麻子"};
Stream<String> st1 = Stream.of(array);
二、常用方法
流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：
- 延迟方法：返回值任然是Stream接口自身类型的方法，因此支持链式调用(除了终结方法外，其他都是方法均为延迟方法)
- 终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder【add的链式调用】那样的链式调用，这里介绍
count和forEach方法其他终结方法请参考API
1.逐一处理:forEach
虽然方法名字叫forEach ，但是与for循环中的“for-each”昵称不同。
void forEach(Consumer<? super T> action);
java.util.function.Consumer<T>接口是一个消费型接口。Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
基本使用：
代码语言：javascript复制Stream<String> st1 = Stream.of("张三","李四","王二","麻子");
st1.forEach(System.out::println);
// 等同于如下代码
// st1.forEach(s -> System.out.println(s));
2.过滤:filter
可以通过filter方法将一个流转换成另一个子集流。方法签名
Stream<T> filter(Predicate<? super T> predicate);
该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。
java.util.stream.Predicate函数式接口唯一的抽象方法为boolean test(T t);,该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。
基本使用：
代码语言：javascript复制Stream.of("张三","李四","王二","麻子","张三丰","张无忌")
.filter(s -> s.startsWith("张"))
.forEach(System.out::println);
3.映射:map
如果需要将流中的元素映射到另一个流中，可以使用map方法，方法签名：
代码语言：javascript复制<R> Stream<R> map(Function<? super T, ? extends R> mapper);
该接口需要一个Function函数式接口，可以将当前流中的T类型数据转换为另一种R类型的流
代码语言：javascript复制此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：
R apply(T t);,这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”。
Stream.of("1","2","3","4","5","6")
.map(Integer::parseInt)
.forEach(s -> System.out.println(s*10));
这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对象）。
4.统计个数:count
正如旧集合Collection当中的size方法一样，流提供count方法来数一数其中的元素个数：
long count();
该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：
代码语言：javascript复制System.out.println(Stream.of("1", "2", "3", "4", "5", "6")
.map(Integer::parseInt)
.count());
5.取前几个:limit
limit方法可以对流进行截取，只取用前n个。方法签名：
Stream<T> limit(long maxSize);
参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用
代码语言：javascript复制Stream.of("1", "2", "3", "4", "5", "6")
.limit(1)
.forEach(System.out::println);
6.跳过前几个:skip
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流；
代码语言：javascript复制Stream<T> skip(long n);
如果流的当前长度大于n,则跳过前n个；否则将会得到一个长度为0的空流。
代码语言：javascript复制Stream.of("1", "2", "3", "4", "5", "6")
.skip(5)
.forEach(System.out::println);
7.组合:count
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
static <T> Stream<T> concat(Stream<? extend T> a, Stream<? extends T> b)
代码语言：javascript复制这是一个静态方法，与
java.lang.String当中的concat方法是不同的。
Stream.concat(
Stream.of("1", "2", "3", "4", "5", "6"),
Stream.of("7")
).forEach(System.out::println);
8.验证流的工作方式
流的工作方式为：先建立流水线[Lambda表达式的延迟执行]，然后通过内部迭代迭代一个走一个，。。。
代码语言：javascript复制ArrayList<String> arr = new ArrayList<>();
arr.add("张翠山");
arr.add("张无忌");
arr.add("张大侠");
arr.add("张三丰");
arr.add("张傻屌");
arr.stream().filter(s -> {
System.out.println("@1");
return s.startsWith("张");
}).filter(s -> {
System.out.println("#2");
return s.length() == 3;
}).forEach(System.out::println);
运行结果
代码语言：javascript复制@1
#2
张翠山
@1
#2
张无忌
@1
#2
张大侠
@1
#2
张三丰
@1
#2
张傻屌
9.并发流的两种获取方式
并发流就是把多扩展几个流水线，将数据成几段交给这些流水线执行。每个流水线拿到上每次只有一个数据在跑。
并发流的两种获取方式：
代码语言：javascript复制Collection<String> coll = new ArrayList<>();
Stream<String> parallelStream1 = coll.parallelStream();
Stream<Integer> parallelStram2 = Stream.of(100,200,300,400,500).parallel();
单线程流和并发流的案例
代码语言：javascript复制 int n = 100000000;
Integer[] arr = new Integer[n];
for (int i = 0; i < arr.length; i ) {
arr[i] = i;
}
ArrayList<Integer> first = new ArrayList<>();
ArrayList<Integer> second = new ArrayList<>();
long start1 = System.currentTimeMillis();
Stream.of(arr)
.filter(a -> a % 2 == 0)
.filter(b -> b % 3 == 0)
.filter(c -> c % 5 == 0)
.filter(d -> d % 7 == 0)
.forEach(first::add);
long end1 = System.currentTimeMillis();
System.out.println("单线程流：" (end1 - start1) "ms");
long start2 = System.currentTimeMillis();
Stream.of(arr).parallel()
.filter(a -> a % 2 == 0)
.filter(b -> b % 3 == 0)
.filter(c -> c % 5 == 0)
.filter(d -> d % 7 == 0)
.forEach(second::add);
long end2 = System.currentTimeMillis();
System.out.println("并发流耗时：" (end2 - start2) "ms");
执行结果
代码语言：javascript复制单线程流：1890ms
并发流耗时：828ms
三、综合应用
- 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
- 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
- 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
- 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
- 将两个队伍合并为一个队伍；存储到一个新集合中。
- 根据姓名创建 Person 对象；存储到一个新集合中。
- 打印整个队伍的Person对象信息。
import java.util.*;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
List<String> one = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("苏星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
List<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("张无忌");
two.add("赵丽颖");
two.add("张三丰");
two.add("尼古拉斯赵四");
two.add("张天爱");
two.add("张二狗");
Stream.concat(
one.stream().filter(s -> s.length() == 3).limit(3),
two.stream().filter(s -> s.startsWith("张")).skip(2)
).map(Person::new).forEach(System.out::println);
}
}
class Person{
private String name;
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "person{"
"name='" name '''
'}';
}
}
