引言

Java8 加入了java.util.stream包，这个包中的相关API将极大的增强容器对象对元素的操作能力。

它专注于对集合对象进行各种便利、高效的聚合操作，或大批量数据处理。

Stream API借助于同样新出现的Lambda表达式，极大的提高了编程效率和程序信噪比。

它提供了串行和并行两种模式进行汇聚操作。并行模式底层采用 Fork / Join 框架来拆分任务和加速处理过程。

什么是流？

一、流的概念

1、流不是数据结构

它没有内部存储，它只是用操作管道从source（数据结构、数组、IO channel）抓取数据。

2、不修改源数据

例如Stream 的 filter操作会产生一个不包含被过滤元素的新的Stream，而不是从source中删除那些元素。

3、流的操作参数

所有的Stream操作必须以Lambda表达式作为参数。

4、不支持索引访问

Stream操作实际上是 增强For循环 的函数编程变式，它没有元素下标的访问方式。

5、流可以转换成数组或者List

6、惰性化

Intermediate操作永远是惰性化的

7、并行能力

当一个集合不要求元素的顺序时，我们可以通过Stream的并行化特性来充分利用多核资源，不需要再写多线程代码，所有对它的操作会自动并行进行。

8、可以是无限的

集合有固定大小，Stream则不必，limit(n)、findFirst()这类short-circuiting操作可以对无限的Stream进行运算并很快完成。

二、流的操作分类

流的操作类型被分为三种：Intermediate、Terminal、short-circuiting 。

Intermediate ：代表流的中间操作，这种操作的目的主要是打开流，做出某种程度的映射或过滤，然后返回一个新的流，交给下一个操作使用。这类操作是惰性的，也就是说，仅仅调用到这类方法，并没有真正开始流的遍历。

Terminal ：一个流只能有一个Terminal操作。所以这必定是流的最后一个操作。而Terminal操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个副作用。

short-circuiting ：对于Intermediate 操作，如果接收的是一个无限大的Stream，则返回一个有限的新Stream；对于Terminal 操作，如果它接收的是一个无限大的Stream，但能在有限的时间计算出结果。

三、惰性化（lazy）

我们说Intermediate操作都是惰性化的，这如何理解？在对于一个Stream进行多次转换操作（Intermediate操作），每次操作都对Stream中的每个元素进行转换，而且是执行多次，这样时间复杂度就是 N（转换次数）个for循环里所有操作都执行完的总和吗？其实不是这样的！

我们说转换操作是Lazy的，多个转换操作只会在Terminal 操作的时候融合进来，一次循环完成。

我们可以这样简单的类比，在Java 8 未引进Stream API的时候，使用命令式进行for循环，并对每个元素进行诸如 if-else 、赋值、计算、获取、添加等操作，而这些操作你可以理解为Stream中的Intermediate操作，只有在for循环真正执行的时候才会执行它们，这就是惰性化的语义，即提前安排好筛选、计算等Intermediate操作，当循环时再执行它们。

常见用法归纳

一、创建流

我们可以通过一个“集合”对象来创建流，这个集合对象并不限于Collection接口，还包含那些能容纳多个对象的容器。

创建流的方式大致可以分为三种：Arrays.stream()、Stream.of()、集合.stream()，下面举例来说明：

1、数组生成流

// 基本类型数组
int[] numx = new int[] { 1, 2, 2, 3, 5 };
// 方法一：
IntStream stream1 = Arrays.stream(numx);// 方法二：
IntStream stream2 = IntStream.of(numx);// 引用类型数组
Integer[] nums = new Integer[] { 1, 2, 2, 3, 5 };// 方法一：
Stream<Integer> stream3 = Arrays.stream(nums);// 方法二：
Stream<Integer> stream4 = Stream.of(nums);

需要注意的是，对于基本数值型，目前有三种对应的包装类型 Stream：

IntStream、LongStream、DoubleStream。当然我们也可以用 Stream<Integer>、Stream<Long> >、Stream<Double>，但是 boxing 和 unboxing 会很耗时，所以特别为这三种基本数值型提供了对应的 Stream。 Java 8 中还没有提供其它数值型 Stream，因为这将导致扩增的内容较多。而常规的数值型聚合运算可以通过上面三种 Stream 进行。

 2、集合生成流

List<Integer> numsList = Arrays.asList( 1, 2, 2, 3, 5 );
// 使用parallelStream会将List进行分段并行处理，因此处理的顺序是不固定的。
Stream<Integer> parallelStream = numsList.parallelStream();

二、流转化为容器(Terminal)

Stream<String> names = Arrays.asList("Tom", "Jerry", "Tim", "Morty").stream();

1、Stream转Array

String[] namesArr = names.toArray(String[]::new);

2、 Stream转Collection

List<String> list1 = names.collect(Collectors.toList());
// 或
List<String> list2 = names.collect(Collectors.toCollection(ArrayList::new));

Set<String> set = names.collect(Collectors.toSet());
Stack<String> stack = names.collect(Collectors.toCollection(Stack::new));

3、Stream转String

String str = names.collect(Collectors.joining());// joining()有重载

 三、映射操作（Intermediate）

map将input stream中的每一个元素，映射成output  stream中的另外一个元素(一对一映射)

List<String> output = names.map(String::toUpperCase).collect(Collectors.toList());

四、多集合映射操作（Intermediate）

flatMap（功能和map相同，只不过映射是一对多），flatMap 把 input Stream 中的层级结构扁平化，就是将最底层元素抽出来放到一起。

List<String> names1 = Arrays.asList("Tom", "Jerry", "Tim", "Morty");
List<String> names2 = Arrays.asList("Tony", "Jack", "Tina", "Marry");
List<String> collect = Stream.of(names1, names2).flatMap(ns -> ns.stream().map(String::toLowerCase)).collect(Collectors.toList());

五、筛选操作（Intermediate）

filter对原始 Stream 进行某项测试，符合条件表达式的元素被留下来生成一个新 Stream 或集合。

Integer[] sixNums = { 1, 2, 3, 4, 5, 6 };
Integer[] evens = Stream.of(sixNums).filter(n -> n % 2 == 0).toArray(Integer[]::new);

六、循环操作（Terminal）

forEach() 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。

但一般认为，forEach 和常规 for 循环的差异不涉及到性能，它们仅仅是函数式风格与传统 Java 风格的差别.

注意:forEach 不能修改自己包含的本地变量值，也不能用 break/return 之类的关键字提前结束循环。

当需要为多核系统优化时，可以 parallelStream().forEach()。另外一点需要注意，forEach 是 terminal 操作。具有相似功能的 intermediate 操作 peek 可以达到上述目的。

Stream.of("one", "two", "three", "four").filter(e -> e.length() > 3).peek(e -> System.out.println("Filtered value: " + e)).map(String::toUpperCase).peek(e -> System.out.println("Mapped value: " + e)).collect(Collectors.toList());

七、第一个元素（Terminal）

findFirst是一个 termimal 兼 short-circuiting 操作，它总是返回 Stream 的第一个元素，或者空。

注意，它的返回值类型：Optional。使用Optional的目的是尽可能避免 NullPointerException。它提供的是编译时检查，能极大的降低 NPE 这种 Runtime Exception 对程序的影响。

Optional<String> firstName = names2.stream().findFirst();

八、聚合操作（Terminal）

reduce方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。

下面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，由于可能没有足够的元素，返回的是 Optional，请留意这个区别。

// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); 
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串连接，concat = "ace"
String s = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("", String::concat);

九、limit/skip （Short-circuiting）

limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素（它是由一个叫 subStream 的方法改名而来）。

List<String> persons = new ArrayList<>();
for (int i = 1; i <= 10000; i++) {persons.add(new String("name" + i));
}
List<String> personNameList = persons.stream().map(String::toUpperCase).limit(10).skip(3).collect(Collectors.toList());

 上述代码是一个有 10000 个元素的 Stream，但在 short-circuiting 操作 limit 和 skip 的作用下，管道中 map 操作指定的toUpperCase()方法的执行次数为 limit 所限定的 10 次，而最终返回结果再跳过前 3 个元素后只有后面 7 个返回。

执行结果：

注意，有一种情况 limit/skip 无法达到 short-circuiting 目的，就是把它们放在 Stream 的排序操作后，原因跟 sorted这个 intermediate 操作有关：此时系统并不知道 Stream 排序后的次序如何，所以 sorted 中的操作看上去就像完全没有被 limit 或者 skip 一样。

经典案例：内存全量数据实现分页返回：

如下代码所示，page 从 1 开始，分别翻页查询，可以得到完美的分页输出结果。

其中skip代表一个偏移量，limit代表输出限制，由此方式达到了 SQL 语句中 limit x, y 的效果。

public class TestMemoryPage {public static final List<String> totalNameList = new ArrayList<>();static {for (int i = 1; i <= 100; i++) {totalNameList.add("name"+ i);}}public static void main(String[] args) {// 可自由调整分页大小int pageSize = 9;int total = totalNameList.size();int totalPage = (total + pageSize - 1) / pageSize;System.out.println(totalNameList);System.out.println("pageSize = "+pageSize+", total = "+total+", totalPage = "+totalPage);// 分页开始for (int page = 1; page <= totalPage; page++) {List<String> pageList = totalNameList.stream().skip((page - 1) * pageSize).limit(pageSize).collect(Collectors.toList());System.out.println("第"+page+"页，数量："+pageList.size()+" 数据：" + pageList);}}
}

十、排序操作（Intermediate）

对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。

List<String> pList = persons.stream().limit(2).sorted((p1, p2) -> p1.toString().compareTo(p2.toString())).collect(Collectors.toList());

 十一、最大/最小值、去重操作（Intermediate）

min 和 max 的功能也可以通过对 Stream 元素先排序，再 findFirst 来实现，但前者的性能会更好，为 O(n)，而 sorted 的成本是 O(n log n)。同时它们作为特殊的 reduce 方法被独立出来也是因为求最大最小值是很常见的操作。

BufferedReader br = new BufferedReader(new FileReader("c:\\noThisFile.txt"));
int longest = br.lines().mapToInt(String::length).max().getAsInt();br.close();
System.out.println(longest);

十二、匹配操作（Terminal）

Stream 有三个 match 方法，从语义上说：

allMatch：Stream 中全部元素符合传入的 predicate，返回 true 

anyMatch：Stream中只要有一个元素符合传入的 predicate，返回 true

noneMatch：Stream 中没有一个元素符合传入的predicate，返回 true

它们都不是要遍历全部元素才能返回结果。例如 allMatch 只要一个元素不满足条件，就 skip 剩下的所有元素，返回 false。

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);

十三、常用聚合函数案例

数据准备，声明一个User对象，然后初始化一个user 列表：

@Data
@AllArgsConstructor
public static class User implements Jsonable {private Long id;private String name;private Integer age;private String address;private String group;@Overridepublic String toString() {return this.toJsonStr();}
}public static final List<User> users = new ArrayList<>();static {User morty = new User(1L, "morty", 28, "昌平区天通中苑", "研发组");User tom = new User(2L, "tom", 24, "朝阳区将台街道", "研发组");User lucy = new User(3L, "lucy", 22, "朝阳区美景东方小区", "测试组");users.add(morty);users.add(tom);users.add(lucy);
}

13.1 提取某一列

List<String> names = users.stream().map(User::getName).collect(Collectors.toList());
System.out.println("names = " + names);// names = [morty, tom, lucy]

13.2 连接某一列

String joiningNames = users.stream().map(User::getName).collect(Collectors.joining("_"));
System.out.println("joiningNames = " + joiningNames);// joiningNames = morty_tom_lucy

13.3 映射表

Map<Long, User> userMapping = users.stream().collect(Collectors.toMap(User::getId, o -> o));
System.out.println("userMapping = " + userMapping);// userMapping = {1={"address":"昌平区天通中苑","name":"morty","id":1,"age":28,"group":"研发组"}, 2={"address":"朝阳区将台街道","name":"tom","id":2,"age":24,"group":"研发组"}, 3={"address":"朝阳区美景东方小区","name":"lucy","id":3,"age":22,"group":"测试组"}}

13.4 按某列分组

Map<String, List<User>> userGroups = users.stream().collect(Collectors.groupingBy(User::getGroup));
System.out.println("userGroups = " + userGroups);// userGroups = {测试组=[{"address":"朝阳区美景东方小区","name":"lucy","id":3,"age":22,"group":"测试组"}], 研发组=[{"address":"昌平区天通中苑","name":"morty","id":1,"age":28,"group":"研发组"}, {"address":"朝阳区将台街道","name":"tom","id":2,"age":24,"group":"研发组"}]}

鸣谢

《Java 8 中的 Streams API 详解》