本节将介绍如何从值序列、数组、文件来创建流,甚至由生成函数来创建无限流!
由值创建流
你可以使用静态方法Stream.of,通过显式值创建一个流。它可以接受任意数量的参数。例 如,以下代码直接使用Stream.of创建了一个字符串流。然后,你可以将字符串转换为大写,再 一个个打印出来:
Stream stream = Stream.of("Java 8 ", "Lambdas ", "In ", "Action");
stream.map(String::toUpperCase).forEach(System.out::println);
你可以使用empty得到一个空流,如下所示:
Stream emptyStream = Stream.empty();
由数组创建流
你可以使用静态方法Arrays.stream从数组创建一个流。它接受一个数组作为参数。例如, 你可以将一个原始类型int的数组转换成一个IntStream,如下所示:
int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum();
由文件生成流
Java中用于处理文件等I/O操作的NIO API(非阻塞 I/O)已更新,以便利用Stream API。 java.nio.file.Files中的很多静态方法都会返回一个流。例如,一个很有用的方法是 Files.lines,它会返回一个由指定文件中的各行构成的字符串流。使用你迄今所学的内容, 你可以用这个方法看看一个文件中有多少各不相同的词:
long uniqueWords = 0;
try(Stream<String> lines =
Files.lines(Paths.get("file/data.txt"), Charset.defaultCharset())){ //流会自动关闭
uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" "))) //生成单词流
.distinct() //删除重复项
.count(); // 数一数有多少各不相同的单词
}
catch(IOException e){ //如果打开文件时出现异常则加以处理
}
你可以使用Files.lines得到一个流,其中的每个元素都是给定文件中的一行。然后,你 可以对line调用split方法将行拆分成单词。应该注意的是,你该如何使用flatMap产生一个扁 平的单词流,而不是给每一行生成一个单词流。最后,把distinct和count方法链接起来,数 数流中有多少各不相同的单词。
由函数生成流:创建无限流
Stream API提供了两个静态方法来从函数生成流:Stream.iterate和Stream.generate。 这两个操作可以创建所谓的无限流:不像从固定集合创建的流那样有固定大小的流。由iterate 和generate产生的流会用给定的函数按需创建值,因此可以无穷无尽地计算下去!一般来说, 应该使用limit(n)来对这种流加以限制,以避免打印无穷多个值。
-
1. 迭代
我们先来看一个iterate的简单例子,然后再解释:
Stream.iterate(0, n -> n + 2)
.limit(10)
.forEach(System.out::println);
iterate方法接受一个初始值(在这里是0),还有一个依次应用在每个产生的新值上的 Lambda(UnaryOperator类型)。这里,我们使用Lambda n -> n + 2,返回的是前一个元 素加上2。因此,iterate方法生成了一个所有正偶数的流:流的第一个元素是初始值0。然后加 上2来生成新的值2,再加上2来得到新的值4,以此类推。这种iterate操作基本上是顺序的, 因为结果取决于前一次应用。请注意,此操作将生成一个无限流——这个流没有结尾,因为值是 按需计算的,可以永远计算下去。我们说这个流是无界的。正如我们前面所讨论的,这是流和集 合之间的一个关键区别。我们使用limit方法来显式限制流的大小。这里只选择了前10个偶数。 然后可以调用forEach终端操作来消费流,并分别打印每个元素。
一般来说,在需要依次生成一系列值的时候应该使用iterate,比如一系列日期:1月31日, 2月1日,依此类推。来看一个难一点儿的应用iterate的例子,试试测验
测验:斐波纳契元组序列
斐波纳契数列是著名的经典编程练习。下面这个数列就是斐波纳契数列的一部分:0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55…数列中开始的两个数字是0和1,后续的每个数字都是前两个数字之和。
斐波纳契元组序列与此类似,是数列中数字和其后续数字组成的元组构成的序列:(0, 1), (1, 1), (1, 2), (2, 3), (3, 5), (5, 8), (8, 13), (13, 21) …
你的任务是用iterate方法生成斐波纳契元组序列中的前20个元素。
让我们帮你入手吧。第一个问题是,iterate方法要接受一个UnaryOperator作为 参数,而你需要一个像(0,1)这样的元组流。你还是可以(这次又是比较草率地)使用一个数组 的两个元素来代表元组。例如,new int[]{0,1}就代表了斐波纳契序列(0, 1)中的第一个元 素。这就是iterate方法的初始值:
Stream.iterate(new int[]{0, 1}, ???) .limit(20) .forEach(t -> System.out.println("(" + t[0] + "," + t[1] +")"));
在这个测验中,你需要搞清楚???代表的代码是什么。请记住,iterate会按顺序应用给 定的Lambda。
答案:
Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0]+t[1]}) .limit(20) .forEach(t -> System.out.println("(" + t[0] + "," + t[1] +")"));
它是如何工作的呢?iterate需要一个Lambda来确定后续的元素。对于元组(3, 5),其后 续元素是(5, 3+5) = (5, 8)。下一个是(8, 5+8)。看到这个模式了吗?给定一个元组,其后续的元 素是(t[1], t[0] + t[1])。这可以用这个Lambda来计算:t->new int[]{t[1], t[0]+t[1]}。 运行这段代码,你就得到了序列(0, 1), (1, 1), (1, 2), (2, 3), (3, 5), (5, 8), (8, 13), (13, 21)…请注意, 如果你只想打印正常的斐波纳契数列,可以使用map提取每个元组中的第一个元素:
Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1],t[0] + t[1]}) .limit(10) .map(t -> t[0]) .forEach(System.out::println);
这段代码将生成斐波纳契数列:0, 1, 1, 2, 3, 5, 8, 13, 21, 34…
- 2. 生成
与iterate方法类似,generate方法也可让你按需生成一个无限流。但generate不是依次 对每个新生成的值应用函数的。它接受一个Supplier类型的Lambda提供新的值。我们先来 看一个简单的用法:
Stream.generate(Math::random)
.limit(5)
.forEach(System.out::println);
这段代码将生成一个流,其中有五个0到1之间的随机双精度数。例如,运行一次得到了下面 的结果:
0.9410810294106129
0.6586270755634592
0.9592859117266873
0.13743396659487006
0.3942776037651241
Math.Random静态方法被用作新值生成器。同样,你可以用limit方法显式限制流的大小, 否则流将会无限长。
你可能想知道,generate方法还有什么用途。我们使用的供应源(指向Math.random的方 法引用)是无状态的:它不会在任何地方记录任何值,以备以后计算使用。但供应源不一定是无 状态的。你可以创建存储状态的供应源,它可以修改状态,并在为流生成下一个值时使用。举个 例子,我们将展示如何利用generate创建测验中的斐波纳契数列,这样你就可以和用 iterate方法的办法比较一下。但很重要的一点是,在并行代码中使用有状态的供应源是不安全 的。因此下面的代码仅仅是为了内容完整,应尽量避免使用!
我们在这个例子中会使用IntStream说明避免装箱操作的代码。IntStream的generate方 法会接受一个IntSupplier,而不是Supplier。例如,可以这样来生成一个全是1的无限流:
IntStream ones = IntStream.generate(() -> 1);
Lambda允许你创建函数式接口的实例,只要直接内联提供方法的实 现就可以。你也可以像下面这样,通过实现IntSupplier接口中定义的getAsInt方法显式传递 一个对象(虽然这看起来是无缘无故地绕圈子,也请你耐心看):
IntStream twos = IntStream.generate(new IntSupplier(){
public int getAsInt(){
return 2;
}
});
generate方法将使用给定的供应源,并反复调用getAsInt方法,而这个方法总是返回2。 但这里使用的匿名类和Lambda的区别在于,匿名类可以通过字段定义状态,而状态又可以用 getAsInt方法来修改。这是一个副作用的例子。你迄今见过的所有Lambda都是没有副作用的; 它们没有改变任何状态。
回到斐波纳契数列的任务上,你现在需要做的是建立一个IntSupplier,它要把前一项的 值保存在状态中,以便getAsInt用它来计算下一项。此外,在下一次调用它的时候,还要更新 IntSupplier的状态。下面的代码就是如何创建一个在调用时返回下一个斐波纳契项的 IntSupplier:
IntSupplier fib = new IntSupplier(){
private int previous = 0;
private int current = 1;
public int getAsInt(){
int oldPrevious = this.previous;
int nextValue = this.previous + this.current;
this.previous = this.current;
this.current = nextValue;
return oldPrevious;
}
};
IntStream.generate(fib).limit(10).forEach(System.out::println);
前面的代码创建了一个IntSupplier的实例。此对象有可变的状态:它在两个实例变量中 记录了前一个斐波纳契项和当前的斐波纳契项。getAsInt在调用时会改变对象的状态,由此在 每次调用时产生新的值。相比之下,使用iterate的方法则是纯粹不变的:它没有修改现有状态, 但在每次迭代时会创建新的元组。你将在以后了解到,你应该始终采用不变的方法,以便并行 处理流,并保持结果正确。请注意,因为你处理的是一个无限流,所以必须使用limit操作来显 式限制它的大小;否则,终端操作(这里是forEach)将永远计算下去。同样,你不能对无限流 做排序或归约,因为所有元素都需要处理,而这永远也完不成!