Java8————Stream API

引言

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 一样。

十、排序操作(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);

鸣谢

Java 8 中的 Streams API 详解

相关推荐
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页