Java8Stream从入门到进阶——像SQL一样玩转集合

0.阅读完本文你将会

• 了解Stream的定义和它的特征
• 了解Stream的基础和高阶用法

1. 前言

在我们日常使用Java的过程中&＃xff0c;免不了要和集合打交道。对于集合的各种操作有点类似于SQL——增删改查以及聚合操作&＃xff0c;但是其方便性却不如SQL。

所以有没有这样一种方式可以让我们不再使用一遍又一遍的循环去处理集合&＃xff0c;而是能够便捷地操作集合&＃xff1f;

答案是有的&＃xff0c;它就是——Java 8引入的Stream&＃xff0c;亦称为流 。

2. 流的定义

A Stream is a sequence of elements from a source.

流是一个来自数据源的元素队列。

简单来说&＃xff0c;流是对数据源的包装&＃xff0c;它允许我们对数据源进行聚合操作&＃xff0c;并且可以方便快捷地进行批量处理。

日常生活中&＃xff0c;我们看见水流在管道中流淌。Java中的流也是可以在“管道”中传输的。并且可以在“管道”的节点进行处理&＃xff0c;比如筛选&＃xff0c;排序等。

&＃43;--------------------&＃43; &＃43;------&＃43; &＃43;------&＃43; &＃43;---&＃43; &＃43;-------&＃43;
| stream of elements &＃43;-----> |filter&＃43;-> |sorted&＃43;-> |map&＃43;-> |collect|
&＃43;--------------------&＃43; &＃43;------&＃43; &＃43;------&＃43; &＃43;---&＃43; &＃43;-------&＃43;


元素流在管道中经过中间操作&＃xff08;intermediate opertaion&＃xff09;的处理&＃xff0c;最后由终端操作&＃xff08;terminal opertaion&＃xff09;得到前面处理的结果&＃xff08;每一个流只能有一次终端处理&＃xff09;。

中间操作可以分为无状态操作和有状态操作&＃xff0c;前者是指元素的处理不受之前元素的影响&＃xff1b;后者是指该操作只有拿到所有元素才能继续下去。

终端操作也可分为短路与非短路操作&＃xff0c;前者是指遇到符合条件的元素就可以得到最终结果&＃xff0c;而后者必须处理所有元素才能得到最终结果。

下图为我们展示了中间操作和终端操作的具体方法。

如何快速区分中间操作和终端操作&＃xff1f;

看方法的返回值&＃xff0c;返回值为Stream的一般都是中间操作&＃xff0c;否则是终端操作。

再来看看流的特征&＃xff1a;

1. 流并不存储数据&＃xff0c;所以它不是一个数据结构&＃xff0c;它也不会修改底层的数据源&＃xff0c;它为了函数式编程而生。

2. 惰性执行的&＃xff0c;例如filter,map等都是延迟执行的。流的中间操作总是惰性的。

当终端操作需要中间操作时&＃xff0c;中间操作才会被调用。

我们来看一个说明这点的例子&＃xff1a;

List list &＃61; Arrays.asList("a", "b", "c");
Stream stream &＃61; list.stream().filter(element -> {System.out.println("filter() was invoked");return element.contains("b");});


上面这段代码告诉我们&＃xff0c;流的元素有三个&＃xff0c;所以我们应该是调用三次filter() 方法&＃xff0c;应该打印三次filter() was invoked。

但实际上一次也没有打印&＃xff0c;这就说明其实filter() 方法没有调用过一次。这是因为代码中缺失了终端操作。

我们改动下代码&＃xff0c;添加一个map()方法以及终端操作。

List list &＃61; Arrays.asList("a", "b", "c");
Optional stream &＃61; list.stream().filter(element -> {System.out.println("filter() was invoked");return element.contains("b");
}).map(ele -> {System.out.println("map() was invoked");return ele.toUpperCase();
}).findFirst();


输入结果如下&＃xff1a;

filter() was invoked
filter() was invoked
map() was invoked


打印结果显示&＃xff0c;我们调用了两次filter() 方法&＃xff0c;一次map() 方法。

在上面这段代码中&＃xff0c;流的第一个元素不符合filter的条件&＃xff0c;然后第二次调用&＃xff0c;找到了符合的元素&＃xff0c;接下来程序没有第三次调用filter()方法&＃xff0c;而是"顺着管道"直接调用了map() 方法。

因为findFirst() 方法只选取第一个元素&＃xff0c;所以我们至少少调用了一个filter() 方法。这正是因为惰性调用的机制。

1. 流有可能是无限的。虽然集合具有有限的大小&＃xff0c;但流不需要。短路操作&＃xff0c;如limit(n)或findFirst()&＃xff0c;允许在有限的时间内完成对无限流的计算。

2. 流还是消耗品。在流的生命周期中&＃xff0c;流的元素只被访问一次。与迭代器一样&＃xff0c;必须生成新的流来重新访问源的相同元素。被访问过的流会被关闭。

针对第4点&＃xff0c;我们看一个例子。

IntStream intStream &＃61; IntStream.of(1, 2, 3);
OptionalInt anyElement &＃61; intStream.findAny();
OptionalInt firstElement &＃61; intStream.findFirst();


执行这段代码将会得到以下的报错java.lang.IllegalStateException&＃xff1a;

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed


因为代码中的intStream已经经历过一次了终端操作findAny(),所以intStream已经被关闭&＃xff0c;再执行一次终端操作就会报错。

这种设计是符合逻辑和流的特性&＃xff0c;因为流并不是为了存储元素。

我们将代码改成下面这样的&＃xff0c;就可以执行多次终端操作了。

int[] intArray &＃61; {1, 2, 3};
OptionalInt anyElement &＃61; Arrays.stream(intArray).findAny();
OptionalInt firstElement &＃61; Arrays.stream(intArray).findFirst();


以上这些特征将Stream与Collection区分开来。

请注意&＃xff0c;这里的Stream“流”与Java I/O流是不同的。它们之间的关系很小。

3. 创建一个流

创建一个Java流有许多方式。一旦流被创建了&＃xff0c;那么它是无法修改数据源的&＃xff0c;所以针对一个数据源我们可以创建多个流。

3.1 创建一个空的流

我们可以使用empty() 方法来创建一个空的流&＃xff1a;

Stream emptyStream &＃61; Stream.empty();


我们还可以用empty() 方法来返回一个空流从而避免返回null&＃xff1a;

public Stream streamOf(List list) {return list &＃61;&＃61; null || list.isEmpty() ? Stream.empty() : list.stream();
}


3.2 使用数组创建流

我们可以使用数组的全部或者一部分来创建流&＃xff1a;

String[] arr &＃61; new String[]{"1", "2", "3"&＃xff0c;"4", "5"};
Stream entireArrayStream &＃61; Arrays.stream(arr);
Stream partArrayStream &＃61; Arrays.stream(arr, 1, 4);


3.3 使用集合创建流

我们也可以使用集合来创建流&＃xff1a;

Collection collection &＃61; Arrays.asList("1", "2", "3");
Stream collectionStream &＃61; collection.stream();


3.4 使用Stream.Builder()来创建流

使用这种方式创建流的时候请注意&＃xff0c;一定要声明好你想要的类型&＃xff0c;否则创建的会是Stream的流&＃xff1a;

Stream streamBuilder &＃61;Stream.builder().add("1").add("2").add("3").build();


3.5 使用File来创建流

我们可以通过Files.lines()方法来创建流。文件的每一行都会成为流的每一个元素。

Path path &＃61; Paths.get("C:\\tmp\\file.txt");Stream fileStream &＃61; Files.lines(path);Stream fileStreamWithCharset &＃61; Files.lines(path, Charset.forName("UTF-8"));


3.6 Stream.iterate()

我们还可以使用iterate() 来创建一个流&＃xff1a;

Stream iteratedStream &＃61; Stream.iterate(10, n -> n &＃43; 1).limit(10);


在上面这段代码中&＃xff0c;将会创造一个连续元素的流。

第1个元素是10&＃xff0c;第2个元素是11&＃xff0c;依此类推&＃xff0c;直到元素数量达到size。

3.7 Stream.generate()

generate() 方法接受一个Supplier来生成元素。

因为流是无限的&＃xff0c;所以我们需要设置流的size。

下面这段代码将会创建一个流&＃xff0c;它包含了5个"ele"字符串。

Stream generatedStream &＃61;Stream.generate(() -> "ele").limit(5);


3.8 基本类型的流

1. range()和rangeClosed()

在Java8中&＃xff0c;三种基本类型——int,long,double可以创建对应的流。

因为Stream是泛型接口&＃xff0c;所以无法用基本类型作为类型参数&＃xff0c;因为我们使用IntStream&＃xff0c;LongStream&＃xff0c;DoubleStream来创建流。

IntStream intStream &＃61; IntStream.range(1, 3);//1,2
LongStream longStream &＃61; LongStream.rangeClosed(1, 3);//1,2,3


range(int start, int end) 方法会创建一个从start到end的有序流&＃xff0c;它的步长是1&＃xff0c;但是它不包括end。

rangeClosed(int start, int end) 与range() 方法的区别在于&＃xff0c;前者会包括end。

2. of()方法

此外&＃xff0c;基本类型还可以通过of() 方法来创建流。

int[] intArray &＃61; {1,2,3};
IntStream intStream &＃61; IntStream.of(intArray);//1,2,3
IntStream intStream2 &＃61; IntStream.of(1, 2, 3);//1,2,3long[] longArray &＃61; {1L, 2L, 3L};
LongStream longStream &＃61; LongStream.of(longArray);//1,2,3
LongStream longStream2 &＃61; LongStream.of(1L, 2L, 3L);//1,2,3double[] doubleArray &＃61; {1.0, 2.0, 3.0};
DoubleStream doubleStream &＃61; DoubleStream.of(doubleArray);
DoubleStream doubleStream2 &＃61; DoubleStream.of(1.0, 2.0, 3.0);//1.0,2.0,3.0


3. Random类

另外&＃xff0c;从Java8开始&＃xff0c;Random类也提供了一系列的方法来生成基本类型的流。例如&＃xff1a;

Random random &＃61; new Random();
IntStream intStream &＃61; random.ints(3);
LongStream longStream &＃61; random.longs(3);
DoubleStream doubleStream &＃61; random.doubles(3);

3.9 字符串的流

1. 字符的流

因为Java没有CharStream&＃xff0c;所以我们用InStream来替代字符的流。

IntStream charStream &＃61; "abc".chars();

2. 字符串的流

我们可以通过正则表达式来创建一个字符串的流。

Stream stringStream &＃61; Pattern.compile(",").splitAsStream("a,b,c");


4. 流的用法

4.1 基本用法

4.1.1 forEach()方法

我们对forEach() 方法应该很熟悉了&＃xff0c;在Collection中就有。它的作用是对每个元素执行指定的动作&＃xff0c;也就是对元素进行遍历。

Arrays.asList("Try", "It", "Now").stream().forEach(System.out::println);


输出结果&＃xff1a;

Try
It
Now


1. 方法引用

可能会有读者疑惑System.out::println是什么写法&＃xff0c;正常的写法不应该都是下面这样嘛&＃xff1f;

Arrays.asList("Try", "It", "Now").stream().forEach(ele -> System.out.println(ele));


其实两者写法是等价的&＃xff0c;只不过前者是后者的简写方式。前者这种语法形式叫做方法引用(method references)&＃xff0c;这种语法用来替代某些特定形式的lambda表达式。

如果lambda表达式的全部内容就是调用一个已有方法&＃xff0c;那么可以用方法引用来替代lambda表达式。

这一点很重要&＃xff0c;也很值得学习&＃xff0c;在下面的内容中也会有很多这样的简写。

我们插个题外话&＃xff0c;我们可以将方法引用细分为以下四类&＃xff1a;

而System.out::println就是引用了某个对象的方法。

2. 副作用

其实在上面这个例子中&＃xff0c;我们使用forEach() 将结果打印出来是一个常见的使用副作用(Side-effects)的场景。

但是除了这场景之外&＃xff0c;我们应该避免使用流的副作用。

按照我自己的理解就是&＃xff0c;不要去修改函数外部的状态&＃xff0c;不要在中间操作中对lambda表达式之外的属性产生写操作。

特别是在并行流里&＃xff0c;这种操作会导致结果无法预测&＃xff0c;因为并行流是无序的。

// 错误
List list &＃61; new ArrayList<>();
stream.filter(s -> pattern.matcher(s).matches()).forEach(s -> list.add(s));//错误的副作用使用场景
// 正确
List list2 &＃61;stream.filter(s -> pattern.matcher(s).matches()).collect(Collectors.toList());//无副作用


4.1.2 filter()方法

filter() 方法的作用是返回符合条件的Stream。

Arrays.asList("Try", "It", "Now").stream().filter(ele -> ele.length() &＃61;&＃61; 3).forEach(System.out::println);


输出结果&＃xff1a;

Try
Now


4.1.3 distinct()方法

distinct() 方法返回一个去重的stream。

Arrays.asList("Try", "It", "Now", "Now").stream().distinct().forEach(System.out::println);


4.1.4 sorted()方法

排序函数有两个&＃xff0c;一个是自然顺序&＃xff0c;还有一个是自定义比较器排序。

Arrays.asList("Try", "It", "Now").stream().sorted((str1, str2) -> str1.length() - str2.length()).forEach(System.out::println);


输出结果&＃xff1a;

It
Try
Now


4.1.5 map()方法

map() 方法对每个元素按照某种操作进行转换&＃xff0c;转换后流的元素不会改变&＃xff0c;但是元素类型取决于转换之后的类型。

Arrays.asList("Try", "It", "Now").stream().map(String::toUpperCase)


输出结果&＃xff1a;

TRY
IT
NOW


4.1.6 flatMap()方法

flat的英文就是”平坦的“意思&＃xff0c;而flatMap()方法的作用就是将流的元素摊平&＃xff0c;借助下面这个例子我们更好理解&＃xff1a;

Stream.of(Arrays.asList("Try", "It"), Arrays.asList("Now")).flatMap(list -> list.stream()).forEach(System.out::println);


输出结果&＃xff1a;

Try
It
Now


在上述这段代码中&＃xff0c;原来的stream有两个元素&＃xff0c;分别是两个List&＃xff0c;执行了flatMap()之后&＃xff0c;将每个List都”摊平“成了一个个的元素&＃xff0c;所以会产生一个有三个字符串组成的流。

4.2 归约操作

上一小节介绍了Stream的基本用法&＃xff0c;但是如此强大的流又怎么能止步于此呢&＃xff1f; 下面让我们看看流的重头戏——归约操作。

归约操作&＃xff08;reduction operation&＃xff09;也被称为折叠操作(fold)&＃xff0c;是通过某种连接动作将所有元素汇总成一个结果的过程。元素求和、求最大值、求最小值、求总数&＃xff0c;将所有元素转换成一个集合等都属于归约操作。

Stream类库有两个通用的归约操作reduce()和collect() &＃xff0c;也有一些为简化书写而设计的专用归约操作&＃xff0c;比如sum()、max()、min()、count()等。

这些都比较好理解&＃xff0c;所以我们会重点介绍reduce()和collect()。

4.2.1 reduce()

reduce操作可以实现从一组元素中生成一个值&＃xff0c;比如sum()、max()、min()、count()等都是reduce操作。

reduce()方法定义有三种形式&＃xff1a;

Optional reduce(BinaryOperator accumulator)T reduce(T identity, BinaryOperator accumulator) U reduce(U identity, BiFunction accumulator, BinaryOperator combiner)


1. identity-初始值