初识Java 12-2 流
目录
中间操作
跟踪与调试
对流元素进行排序
移除元素
将函数应用于每个流元素
在应用map()期间组合流
Optional类型
便捷函数
创建Optional
Optional对象上的操作
由Optional组成的流
本笔记参考自： 《On Java 中文版》
中间操作
||| 中间操作：从流中接收一个对象，并将对象作为另一个流送出后端，以连接其他操作。
跟踪与调试
peek()操作是用于辅助调试的，它允许我们查看流对象而不修改它。
【例子：peek()的使用流】
public class Peeking {
public static void main(String[] args)
throws Exception {
FileToWords.stream("Cheese.dat")
.skip(21)
.limit(4)
.map(w -> w + " ")
.peek(System.out::print) // 查看当前流的状态
.map(String::toUpperCase)
.peek(System.out::print)
.map(String::toLowerCase)
.forEach(System.out::print);
}
}程序执行的结果是：
其中，FileToWords类的形式如下（之后会再展示）：
这个类的作用就是生成一个String对象组成的流。
当流在管线中传输时，我们使用了peek()进行观察。这里要注意的是，peek()接受的是一个遵循Consumer函数式接口的函数：
这样的函数没有返回值（Consumer一般用于对输入元素进行消费），所以也就不可能使用不同的对象替换流中的对象。因此我们只能“观察”这些对象。
对流元素进行排序
sorted()方法可用于流的排序，它有一种可以接受一个Comparator参数的形式：
【例子：接受参数的sorted()】
import java.util.Comparator;
public class SortedComparator {
public static void main(String[] args)
throws Exception {
FileToWords.stream("D:\\code\\Java\\Test_Java\\src\\streams\\Cheese.dat")
.skip(10)
.limit(10)
.sorted(Comparator.reverseOrder())
.map(w -> w + " ")
.forEach(System.out::print);
System.out.println();
}
}程序执行的结果是：
也可以传入一个lambda表达式作为sorted()的参数，不过也有许多预设的Comparator。
移除元素
介绍两个用于从流中移除元素的操作：
- distinct()：可用于移除流中的重复元素。与Set相比，distinct()要更加简洁。
- filter(Predicate)：过滤，只保留符合特定条件（结果为true）的元素。
distinct()在笔记12-1的Randoms.java中出现过。这里演示filter(Predicate)操作：
【例子：filter(Predicate)的使用例】
import java.util.stream.LongStream;
import static java.util.stream.LongStream.iterate;
import static java.util.stream.LongStream.rangeClosed;
public class Prime {
public static boolean isPrime(long n) {
return rangeClosed(2, (long) Math.sqrt(n)) // rangeClosed()在这里是类似于循环的作用
.noneMatch(i -> n % i == 0); // 若流为空，或流中没有元素能够与当前谓词匹配，返回true
}
public LongStream numbers() {
return iterate(2, i -> i + 1)
.filter(Prime::isPrime); // 若返回结果是true，则保留下来
}
public static void main(String[] args) {
new Prime().numbers()
.limit(10)
.forEach(n -> System.out.format("%d ", n));
System.out.println();
new Prime().numbers()
.skip(90)
.limit(10)
.forEach(n -> System.out.format("%d ", n));
}
}程序执行的结果是：
rangeClosed()的参数是一个左开右闭的区间，包含了上界值。若没有一个取余操作的结果是0，则noneMatch()返回true，否则返回false。并且noneMatch()会在第一次结果为false时退出。
将函数应用于每个流元素
本条目用于介绍一些作用于每个流元素的各种map操作：
- map(Function)：将Function应用于输入流中的每个对象，结果作为输出流继续传递。
以下是map面对不同类型的不同版本：
- mapToInt(ToIntFunction)：应用于IntStream中。
- mapToLong(ToLongFunction)：应用于LongStream中。
- mapToDouble(ToDoubleFunction)：应用于LongStream中。
【例子：将Function（通过map）映射到一个用String组成的流中】
import java.util.Arrays;
import java.util.function.Function;
import java.util.stream.Stream;
public class FunctionMap {
static String[] elements = {"12", "", "23", "45"};
static Stream testStream() {
return Arrays.stream(elements);
}
static void test(String descr, Function func) {
System.out.println(" ---( " + descr + " )---");
testStream()
.map(func)
.forEach(System.out::println);
}
public static void main(String[] args) {
test("添加括号", s -> "[" + s + "]");
test("数值增长", s -> {
try {
return Integer.parseInt(s) + 1 + ""; // parseInt()会尝试将String转换为Integer
} catch (NumberFormatException e) { // 若无法完成转换，抛出异常，执行catch{}中的语句
return s;
}
});
test("替换", s -> s.replace("2", "9"));
test("提取最后一位的数值",
s -> s.length() > 0 ?
s.charAt(s.length() - 1) + "" : s);
}
} 程序执行的结果是：
在语句
return Integer.parseInt(s) + 1 + "";中，表达式从左向右顺序进行，①先尝试将s转换为Integer，②再进行+1操作，③最后将其转换为字符串。
另外，String.charAt()会返回指定索引处的char值。索引的范围是从0到String.length()-1。
---
上述程序中，map()被用于将一个String映射到另一个String。而实际上，并没有约束要求生成的类型必须和输入的类型一致。因此还可以在map()中改变这个流的类型：
【例子：将基本类型的流映射到自定义类型中】
在这个例子中，我们接受的是一个int类型的流，并且使用Numbered::new将其转换为了Numbered。
---
若Function生成的结果是某种数值类型，就需要使用相应的mapTo操作：
【例子：使用mapTo处理数值类型】
import java.util.stream.Stream;
public class FunctionMap3 {
public static void main(String[] args) {
Stream.of("5", "7", "9")
.mapToInt(Integer::parseInt)
.forEach(n -> System.out.format("%d ", n));
System.out.println();
Stream.of("17", "19", "23")
.mapToLong(Long::parseLong)
.forEach(n -> System.out.format("%d ", n));
System.out.println();
Stream.of("17", "1.9", ".23")
.mapToDouble(Double::parseDouble)
.forEach(n -> System.out.format("%f ", n));
}
}程序执行的结果是：
在应用map()期间组合流
假设我们现在有得到了一个由传入元素组成的流，我们需要对其运用map()：
我们希望得到的是一个String类型的流，但结果却是一个由指向其他流的“头”组成的流。换句话说，我们想要的是一个由元素组成的流，但却生成了一个与元素流组成的流。
这种时候就需要使用flatMap()。该方法会做两件事：
- 接受生成流的函数，并将其应用于传入元素（这一点和map()一样）。
- 然后，将每个流“扁平化”处理，将其展开为元素。
和map()类似，flatMap()也有面对不同类型的不同版本（flatMapToInt()、flatMapToLong()等）。
【例子：flatMap()的使用例】
import java.util.stream.Stream;
public class FlatMap {
public static void main(String[] args) {
Stream.of(1, 2, 3)
.flatMap(i -> Stream.of("A", "B", "C"))
.forEach(System.out::println);
}
}程序执行的结果是：
从映射返回的每个流都被自动进行了扁平化处理，展开为组成这个流的String元素。
【例子：flatMapTo生成随机数】
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamOfRandoms {
static Random rand = new Random(47);
public static void main(String[] args) {
Stream.of(1, 2, 3, 4, 5)
.flatMapToInt(i -> IntStream.concat( // concat()会按照参数的顺序将两个流组合到一起
rand.ints(0, 100).limit(i), // 其中的每一个流的长度不超过i
IntStream.of(-1)
))
.forEach(n -> System.out.format("%d ", n));
System.out.println();
}
}程序执行的结果是：
上述程序中出现了concat()
这个方法会按照参数的顺序将两个流组合到一起。所以，在每个有随机的Integer组成的流的末尾，都添加了一个-1作为标记。
因为rand.ints()生成的是一个IntStream，所以这里使用的flatMap()、concat()和of()都是Integer的版本。
在笔记12-1的FileToWordsRegexp.java中，我们将整个文件读取到内存的List中，这是需要存储空间的。但我们真正需要的，是一个不需要中间存储的单词流。这就是flatMap()解决的问题：
【例子：flatMap()创建占用少量内存的流】
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.regex.Pattern;
import java.util.stream.Stream;
public class FileToWords {
public static Stream stream(String filepath)
throws Exception {
return Files.lines(Paths.get(filepath))
.flatMap(line -> Pattern.compile("\\W+").splitAsStream(line));
}
} stream()在这里是一个静态方法，因为它自己就可以完成整个流的创建。
这里还出现了正则表达式\\W+。\\W的意思是一个“非单词字符”，而+意味着“一个或是多个”。
小写形式的\\w是指“单词字符”。
由于语句
Pattern.compile().splitAsStream()会生成一个流，所以若将其应用于map()操作中，我们会得到的是一个由单词流组成的流。而我们仅仅需要一个单词流而已。因此这里需要使用的是flatMap()，将其转化为一个由元素组成的简单流。
除此之外，我们还可以使用String.split()，它会生成一个数组，这个数组可以经由Arrays.stream()转换为一个流：
.flatMap(line -> Arrays.stream(line.split("\\W+")))此时得到的是一个真正的流（而不是像FileToWordsRegexp.java中那样，基于集合创建的流）。因此，每当我们想要一个新的流时，就必须从头创建，并且它无法复用：
【例子：无法复用的流】
public class FileToWordsTest {
public static void main(String[] args)
throws Exception {
FileToWords.stream("Cheese.dat")
.limit(7)
.forEach(s -> System.out.format("%s ", s));
System.out.println();
FileToWords.stream("Cheese.dat")
.skip(7)
.limit(2)
.forEach(s -> System.out.format("%s ", s));
}
}程序执行的结果如下：
Optional类型
在进行编程时，我们或许会认为流被连接成了一条“快乐通道”（指没有异常或错误情形发生的默认场景），并假设没有什么能够中断这个流。但事实是，只需要在流中放入一个null就可以破坏它。
当从流中提取null时，对null进行的类型转换会发生异常。
因此就需要Optional类型。这一类型实现了这样一个概念：存在一个对象，即可以作为流元素来占位，也可以在需要寻找的元素不存在时提醒我们（不会抛出异常）。
某些标准的流操作会返回Optional对象，因为这些操作不能确保所要的结果一定存在：
- findFirst()：返回包含第一个元素的Optional。
- findAny()：返回包含任何元素的Optional。
- max()、min()：返回包含流中最大值或最小值的Optional。
以上三种操作在流为空的时候都返回Optional.empty。
- reduce()的其中一个版本：这个版本不会把一个“identity”对象作为其第一个参数（其他版本中，“identity”是默认结果）,
它的返回值会被包在一个Optional中。
- average()：将数值化的流（IntStream、LongStream和DoubleStream）包在一个Optional中。
【例子：返回Optional类型的操作】
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class OptionalsFromEmptyStreams {
public static void main(String[] args) {
System.out.println(Stream.empty()
.findFirst());
System.out.println(Stream.empty()
.findAny());
System.out.println(Stream.empty()
.max(String.CASE_INSENSITIVE_ORDER));
System.out.println(Stream.empty()
.min(String.CASE_INSENSITIVE_ORDER));
System.out.println(Stream.empty()
.reduce((s1, s2) -> s1 + s2));
System.out.println(IntStream.empty()
.average());
}
} 程序执行的结果是：
此时得到的结果不是抛出的异常，而是Optional.empty()对象。
注意：这里通过Stream.
Stream. s = Stream.empty(); 【例子：Optional的两个基本动作】
import java.util.Optional;
import java.util.stream.Stream;
public class OptionalBasics {
static void test(Optional optString) {
if (optString.isPresent()) // isPresent()：若存在值，返回true
System.out.println(optString.get());
else
System.out.println("流中不存在数据");
}
public static void main(String[] args) {
test(Stream.of("一个元素").findFirst());
test(Stream.empty().findFirst());
}
} 程序执行的结果是：
当接收了一个Optional时，首先调用了isPresent()，对流中元素的存在与否进行测试。
便捷函数
有许多便捷函数，由于获取Optional中的数据。这些函数简化了上述例子的“先检查、再处理”的过程。
- isPresent(Consumer)：若值存在，则使用这个值调用Consumer。否则不进行任何动作。
- orElse(otherObject)：若对象存在，则返回这个对象。否则返回otherObject。
- orElseGet(Supplier)：若对象存在，则返回这个对象。否则返回使用Supplier函数创建的替代对象。
- orElseThrow(Supplier)：若对象存在，则返回这个对象。否则抛出一个使用Supplier函数创建的异常。
【例子：便捷函数】
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class Optionals {
static void basics(Optional optString) {
if (optString.isPresent())
System.out.println(optString.get());
else
System.out.println("流中不存在数据");
}
static void ifPresent(Optional optString) {
optString.ifPresent(System.out::println);
}
static void orElse(Optional optString) {
System.out.println(optString.orElse("从orElse()返回的对象"));
}
static void orElseGet(Optional optString) {
System.out.println(optString.orElseGet(() -> "orElseGet()替换的对象"));
}
static void orElseThrow(Optional optString) {
try {
System.out.println(optString.orElseThrow(
() -> new Exception("orElseThrow()替换的对象")
));
} catch (Exception e) { // 使用catch捕获Java库函数Optional::orElseThrow()抛出的异常
System.out.println("捕获 " + e);
}
}
static void test(String testName
, Consumer> cos) { // 一个可以接收所有示例方法的Consumer，避免代码重复
System.out.println(" === " + testName + " === ");
cos.accept(Stream.of("测试语句").findFirst());
cos.accept(Stream.empty().findFirst());
}
public static void main(String[] args) {
test("basics", Optionals::basics);
test("ifPresent", Optionals::ifPresent);
test("orElse", Optionals::orElse);
test("orElseGet", Optionals::orElseGet);
test("orElseThrow", Optionals::orElseThrow);
}
} 程序执行的结果是：
创建Optional
若要自己编写生成Optional的代码，可以使用以下三种静态方法：
- empty()：返回一个空的Optional。
- of(value)：若已经确定这个value不是null，可以通过该方法将其包在一个Optional中。
- ofNullable(value)：若确定value是否为null，使用这个方法。若value是null，该方法返回Optional.empty()，否则将这个value包在一个Optional中。
【例子：生成Optional的三个方法】
import java.util.Optional;
public class CreatingOptionals {
static void test(String testName, Optional opt) {
System.out.println(" === " + testName + " === ");
System.out.println(opt.orElse("Null"));
}
public static void main(String[] args) {
test("empty", Optional.empty());
test("of", Optional.of("Value"));
try {
test("of", Optional.of(null));
} catch (Exception e) {
System.out.println(e);
}
test("ofNullable", Optional.ofNullable("Value"));
test("ofNullable", Optional.ofNullable(null));
}
} 程序执行的结果如下：
若试图通过of()传递null来创建Optional，就会抛出空指针异常。相比之下，ofNullable()显得更加安全。
Optional对象上的操作
若生成了一个Optional，有三种方法可以在最后再做一项处理：
- filter(Predicate)：将Predicate应用于Optional的内容，并返回其结果。若Optional与Predicate不匹配，则返回empty。若Optional是empty，返回其本身。
- map(Function)：若Optional不是empty，将Function应用于Optional包含的对象，并返回结果。否则返回empty。
- flatMap(Function)：与map()类似，但所提供的映射函数会将结果包在Optional中，这样flatMap()最后就不会再做任何包装了。
但是，数值化的Optional上没有上述的这些操作。
filter()方法存在于普通的流中和在Optional中。但它们的行为并不相同，在普通的流中，若Predicate返回false，filter()会将元素从流中删除。而Optional中的filter()则会将其转换为empty。
【例子：filter()的用法】
import java.util.Arrays;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class OptionalFilter {
static String[] elements = {
"Foo", "", "Bar", "Baz", "Bingo"
};
static Stream testStream() {
return Arrays.stream(elements);
}
static void test(String descr, Predicate pred) {
System.out.println(" ---( " + descr + " )---");
for (int i = 0; i <= elements.length; i++) {
System.out.println(
testStream() // 注意：每次进入for循环，都会重新获取一个流
.skip(i)
.findFirst()
.filter(pred)
);
}
}
public static void main(String[] args) {
test("true", str -> true);
test("false", str -> false);
test("str != \"\"", str -> str != "");
test("str.length() == 3", str -> str.length() == 3);
test("startsWith(\"B\")", str -> str.startsWith("B"));
}
} 程序执行的结果是：
这次的程序虽然输出结果像一个流，但实际上每次进入for循环都会重新获取一个流。只是skip()操作会跳过元素，以至于结果看上去是一个流。
这次for循环语句的结束条件并不是i < elements.length，而是i <= elements.length。因此最后一个元素事实上会超出这个流，但超出的部分自动变为了一个Optional.empty。
Optional也有自己的map()。不同的是，只有当Optional不为empty时，map()才会应用其的映射函数。
若Optional不为空，则将其传递给函数时，map()会首先提取Optional中的对象。
【例子：Optional.map()的使用例】
import java.util.Arrays;
import java.util.function.Function;
import java.util.stream.Stream;
public class OptionalMap {
static String[] elements = {"12", "", "23", "45"};
static Stream testStream() {
return Arrays.stream(elements);
}
static void test(String descr,
Function func) {
System.out.println(" ---( " + descr + " )---");
for (int i = 0; i <= elements.length; i++) {
System.out.println(
testStream()
.skip(i)
.findFirst() // 生成一个Optional
.map(func)
);
}
}
public static void main(String[] args) {
test("加上括号", s -> "[" + s + "]");
test("递增", s -> {
try {
return Integer.parseInt(s) + 1 + "";
} catch (NumberFormatException e) {
return s;
}
});
test("替换", s -> s.replace("2", "9"));
test("获取最后一位数字", s -> s.length() > 0 ?
s.charAt(s.length() - 1) + "" : s);
}
} 程序执行的结果是：
在函数完成之后，map()会先把结果包在一个Optional中，然后返回。并且，Optional.empty在遇到map()时直接通过，并没有被更改。
Optional的flatMap()被应用于已经会生成Optional的映射函数，所以flatMap()并没有像map()一样进行包装的操作：
【例子：Optional.flatMap()的使用例】
import java.util.Arrays;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Stream;
public class OptionalFlatMap {
static String[] elements = {"12", "", "23", "45"};
static Stream testStream() {
return Arrays.stream(elements);
}
static void test(String descr,
Function> func) { // Function的返回类型是Optional
System.out.println(" ---( " + descr + " )---");
for (int i = 0; i <= elements.length; i++) {
System.out.println(
testStream()
.skip(i)
.findFirst()
.flatMap(func)
);
}
}
public static void main(String[] args) {
// 用Optional.of()将函数括起来
test("加上括号", s -> Optional.of("[" + s + "]"));
test("递增", s -> {
try {
return Optional.of(Integer.parseInt(s) + 1 + "");
} catch (NumberFormatException e) {
return Optional.of(s);
}
});
test("替换", s -> Optional.of(s.replace("2", "9")));
test("获取最后一位数字", s -> Optional.of(s.length() > 0 ?
s.charAt(s.length() - 1) + "" : s));
}
} 程序执行的结果是：
flatMap()和map()唯一的区别在于，flatMap()不会将结果包在Optional中，这件事会交由映射函数来做。
由Optional组成的流
Optional可以处理null值。所以若存在一个可能会生成null值的生成器，并且这个生成器创建了一个流，我们自然会想要将这些元素包含在Optional中。
【例子：由Optional组成的流】
import java.util.Optional;
import java.util.Random;
import java.util.stream.Stream;
public class Signal {
private final String msg;
public Signal(String msg) {
this.msg = msg;
}
public String getMsg() {
return msg;
}
@Override
public String toString() {
return "Signal(" + msg + ")";
}
static Random rand = new Random(47);
public static Signal morse() {
switch (rand.nextInt(4)) {
case 1:
return new Signal("dot");
case 2:
return new Signal("dash");
default:
return null;
}
}
public static Stream> stream() {
return Stream.generate(Signal::morse)
.map(signal -> Optional.ofNullable(signal)); // 使用ofNullable将元素包入Optional中
}
} 当我们需要使用这个流的时候，我们需要考虑如何获取Optional中的对象：
【例子：从Optional的流中获取对象】
import java.util.Optional;
public class StreamOfOptionals {
public static void main(String[] args) {
Signal.stream()
.limit(10)
.forEach(System.out::println);
System.out.println(" ---");
Signal.stream()
.limit(10)
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(System.out::println);
}
}程序执行的结果如下：
从Optional的流中提取对象时，往往会遇到“没有值”的情况。这就需要我们针对不同的应用采取不同的方法。