Java8的新特性Stream

Spring Boot源代码ConfigFileApplicationListener类中的一段代码

private List<Profile> getOtherActiveProfiles(Set<Profile> activatedViaProperty) {
	return Arrays.stream(this.environment.getActiveProfiles()).map(Profile::new)
			.filter((profile) -> !activatedViaProperty.contains(profile))
			.collect(Collectors.toList());
}

这段代码怎么？够简洁明快吧，如果不使用Java8的新特性，想象一下得多少行代码才能实现？但如果没掌握或不了解Java8的新特性，这段代码读起来是不是很酸爽？

Java 8的API中新增了一个处理集合的抽象概念：Stream，中文称作“流”。它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用起来就像使用SQL语句来对数据库执行查询操作一样。可以让你如行云流水一般写出简单、高效、干劲的代码。

什么是Stream
Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列（注意是抽象概念），通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。通俗来说就是你只用告诉“流”你需要什么，便在出口处等待结果接口。

Stream相关概念

Stream操作的过程中涉及到一些相关概念，先了解一下，方便后面统一称谓。

元素：特定类型的对象，比如List里面放置的对象，会形成一个队列。Stream不会存储元素，只是按需计算。
数据源：流的来源，对照上图中的集合，数组，I/O channel， 产生器generator等。
聚合操作：类似SQL语句的各种过滤操作，对照上图中的filter、sorted、map等。
Pipelining：中文词义“流水线”，中间操作会返回流本身，跟我们之前所说的流式（fluent）编程一个概念，这样可对操作进行优化，比如延迟执行（laziness）和短路（short-circuiting)。
内部迭代：传统遍历方式是通过Iterator或For-Each来完成，这是外部迭代。而Stream通过访问者模式（Visitor）实现了内部迭代。
需要注意的是在整个操作的过程中，聚合操作部分可以执行多次操作，但每次操作并不是像传统的集合遍历对集合里面的元素进行转换，而是将操作函数放入一个操作集合中，只有到最后一步（比如for-each打印）时才会一次性执行。

而流和迭代器类似，只能迭代一次。比如，当调用完collect方法之后，流便不能再使用了。

stream操作方法分类

中间聚合操作：map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 skip、 parallel、 sequential、 unordered。

最终输出操作：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、iterator。

短路操作：anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit。

生成流

在 Java 8 中, 生成流有多种方法：Stream接口的静态工厂方法、集合提供的生成方法和其他特殊的生成方法。

of方法

Stream接口的静态工厂方法主要通过重载的of方法：

public static<T> Stream<T> of(T... values);

public static<T> Stream<T> of(T t)

of方法，其生成的Stream是有限长度的，Stream的长度为其内的元素个数。使用示例代码：

Stream<String> stringStream = Stream.of("stream");
Stream<String> stringsStream = Stream.of("测试","stream", "字符串");

generator方法

与of方法对应的generator方法生成的是无限长度的Stream，其元素是由Supplier接口提供的。

public static<T> Stream<T> generate(Supplier<T> s)

使用generate方法生成的Stream通常用于随机数和常量，或需要前后元素间维持着某种状态信息的场景。把 Supplier 实例传递给 Stream.generate() 生成的 Stream，默认是串行（相对 parallel 而言）但无序的（相对 ordered 而言）。

Stream<Double> generateDouble = Stream.generate(Math::random);

Stream<String> generateString = Stream.generate(new Supplier<String>() {
	@Override
	public String get() {
		return "测试";
	}
});

上面两种写法的效果是一样的，第一种采用了Lambda表达式，简化了代码

iterate方法

iterate方法生成的也是无限长度的Stream，是通过函数f迭代对给指定的元素种子而产生无限连续有序Stream，其中包含的元素可以认为是：seed，f(seed),f(f(seed))无限循环。

Stream.iterate(1,i -> i +1).limit(10).forEach(System.out::println);
结果为1，2，3，4，5，6，7，8，9，10

上面的方法可以认为种子（seed）为1，f(seed）为在1的基础上“+1”，依次循环下去，直到达到limit的限制，最后生成对应的Stream。

empty方法

empty方法生成一个空的Stream，不包含任何元素。

Collection接口和数组的默认方法
Collection接口和数组中都提供了默认的生成Stream的方法。直接看源代码：

// Collection中
default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}
// 并行流操作
default Stream<E> parallelStream() {
    return StreamSupport.stream(spliterator(), true);
}


// Arrays中
public static <T> Stream<T> stream(T[] array) {
    return stream(array, 0, array.length);
}

public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
    return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
}

示例代码：

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.stream().forEach(System.out::println);

int[] nums = new int[]{1, 2, 3, 4, 5};
Arrays.stream(nums).forEach(System.out::println);

其他生成方法
关于其他生成方法，比如：Random.ints()、BitSet.stream()、JarFile.stream()、Pattern.splitAsStream(java.lang.CharSequence)、Files.lines(java.nio.file
.Path)等。

操作方法使用
关于操作方法就不进行详细的讲解，更多的以示例的形式展示如何使用。

concat方法
合并两个Stream。如果输入Stream有序，则新Stream有序；如果其中一个Stream为并行，则新Stream为并行；如果关闭新Stream，原Stream都将执行关闭。

Stream.concat(Stream.of("a","b"),Stream.of("c")).forEach(System.out::println);

distinct

Stream中元素去重。

Stream.of(1,1,1).distinct().forEach(System.out::println);
打印结果为1。

filter

根据指定条件进行筛选过滤，留下满足条件的元素。

Stream.of(1, 2, 3, 4, 5).filter(i -> i >= 3).forEach(System.out::println);
打印结果为3，4，5。

map

将Stream中的元素进行映射转换，比如将“a”转为“A”，期间生产了新的Stream。同时为了提升效率，官方也提供了封装好的方法：mapToDouble，mapToInt，mapToLong。

Stream.of("a","b","c").map(item -> item.toUpperCase()).forEach(System.out::println);
Stream.of("a","b","c").map(String::toUpperCase).forEach(System.out::println);
打印结果为A，B，C。

flatMap

将流中的每一个元素映射为一个流，再把每一个流连接成为一个流。期间原有的Stream的元素会被逐一替换。官方提供了三种原始类型的变种方法：flatMapToInt，flatMapToLong和flatMapToDouble。

Stream.of(1, 2, 3).flatMap(i -> Stream.of(i * 10)).forEach(System.out::println);
打印结果为10，20，30。

peek

生成一个相同的Stream，并提供一个消费函数，当新Stream中的元素被消费（执行操作）时，该消费函数会在此之前先执行。

Stream.of(1, 2).peek(i -> System.out.println("peekCall:" + i)).forEach(System.out::println);
打印结果依次为：peekCall:1，1，peekCall:2，2。

ship

跳过前N个元素，取剩余元素，如果没有则为空Stream。

Stream.of(1, 2, 3).skip(2).forEach(System.out::println);
打印结果为3。

sorted

对Stream元素进行排序，可采用默认的sorted()方法进行排序，也可通过sorted(Comparator)方法自定义比较器来进行排序，前者默认调用equals方法来进行比较，

Stream.of(1, 3, 2).sorted().forEach(System.out::println);
打印结果：1，2，3。

limit

限制返回前N个元素，与SQL中的limit相似。

Stream.of(1, 2, 3).limit(2).forEach(System.out::println);
打印结果为：1，2。

collect

收集方法，实现了很多归约操作，比如将流转换成集合和聚合元素等。

Stream.of(1, 2, 3).collect(Collectors.toList());
Stream.of(1, 2, 3).collect(Collectors.toSet());

除了以上的集合转换，还有类似joining字符串拼接的方法，具体可查看Collectors中的实现。

count

返回Stream中元素个数。

Stream.of(1, 2, 3).count();

forEach

遍历Stream中所有元素。示例参考以上设计到的。

forEachOrder

遍历Stream中所有元素，如果Stream设置了顺序，则按照顺序执行（Stream是无序的），默认为元素的插入顺序。

max

根据指定的比较器（Comparator），返回Stream中最大元素的Optional对象，Optional中的value便是最大值。

Optional可以代表一个值或不存在，主要是为了规避返回值为null，而抛出NullPointerException的问题，也是由Java8引入的。但当调用其get()方法时，如果当前值不存在则会抛出异常。

Optional<Integer> max = Stream.of(1, 2, 3).max(Comparator.comparingInt(o -> o));
System.out.println("max:" + max.get());
打印结果：max:3。

min

与max操作相同，功能相反，取最小值。

Optional<Integer> min = Stream.of(1, 2, 3).min(Comparator.comparingInt(o -> o));
System.out.println("min:" + min.get());
打印结果：min:1。

reduce

reduce可实现根据指定的规则从Stream中生成一个值，比如之前提到的count，max和min方法是因为常用而被纳入标准库中。实际上，这些方法都是reduce的操作。

Stream.of(1, 2, 3).reduce(Integer::sum);
Stream.of(1, 2, 3).reduce(0, (a, b) -> a + b);

以上两个方法都是对结果进行求和，不同的是第一个方法调用的是reduce的reduce((T, T) -> T)方法，而第二个调用的是reduce(T, (T, T) -> T)。其中第二个方法的第一个参数0，表示从第0个值开始操作。

allMatch

判断Stream中的所有元素是否满足指定条件。全部满足返回true，否则返回false。

boolean result = Stream.of(1, 2, 3).allMatch(i  -> i > 0);
System.out.println(result);
返回结果：true。

anyMatch

判断Stream中的元素至少有一个满足指定条件。如果至少有一个满足则返回true，否则返回false。

boolean anyResult = Stream.of(1, 2, 3).anyMatch(i  -> i > 2);
System.out.println(anyResult);
返回结果：true。

findAny

获得其中一个元素（使用stream()时找到的是第一个元素；使用parallelStream()并行时找到的是其中一个元素）。如果Stream为空，则返回一个为空的Optional。

Optional<String> any = Stream.of("A", "B", "C").findAny();
System.out.println(any.get());
返回结果：A。

findFirst

获得第一个元素。如果Stream为空，则返回一个为空的Optional。

Optional<String> first = Stream.of("A", "B", "C").findFirst();
System.out.println(first.get());
返回结果：A。

noneMatch

判断Stream中是否所有元素都不满足指定条件。都不满足则返回true，否则false。

boolean noneMatch = Stream.of(1, 2, 3).noneMatch(i  -> i > 5);
System.out.println(noneMatch);
返回结果：true。

统计

通过summaryStatistics方法可获得Stream的一些统计信息。

IntSummaryStatistics summaryStatistics = Stream.of(1, 2, 3).mapToInt((i) -> i).summaryStatistics();
System.out.println("max:" + summaryStatistics.getMax());
System.out.println("min:" + summaryStatistics.getMin());
System.out.println("sum:" + summaryStatistics.getSum());
System.out.println("average:" + summaryStatistics.getAverage());

这里用到了流与数值流直接的转换mapToInt，类似的方法还有mapToDouble、mapToLong。对应获得的数值流还提供了一些额外的方法，就像上面获取不同统计信息的方法一样。

Stream的主要接口类关系图