目录
中间操作
跟踪与调试
对流元素进行排序
移除元素
将函数应用于每个流元素
在应用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<String> testStream() {return Arrays.stream(elements);}static void test(String descr, Function<String, String> 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), // 其中的每一个流的长度不超过iIntStream.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<String> 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.<String>empty().findFirst());System.out.println(Stream.<String>empty().findAny());System.out.println(Stream.<String>empty().max(String.CASE_INSENSITIVE_ORDER));System.out.println(Stream.<String>empty().min(String.CASE_INSENSITIVE_ORDER));System.out.println(Stream.<String>empty().reduce((s1, s2) -> s1 + s2));System.out.println(IntStream.empty().average());}
}
程序执行的结果是:
此时得到的结果不是抛出的异常,而是Optional.empty()对象。
注意:这里通过Stream.<String>empty()创建了空流。若使用的是Stream.empty(),那么Java就无法通过这么有限的上下文信息推断出这个流的类型,但这种语法解决了这一问题:
Stream.<String> s = Stream.empty();
【例子:Optional的两个基本动作】
import java.util.Optional;
import java.util.stream.Stream;public class OptionalBasics {static void test(Optional<String> optString) {if (optString.isPresent()) // isPresent():若存在值,返回trueSystem.out.println(optString.get());elseSystem.out.println("流中不存在数据");}public static void main(String[] args) {test(Stream.of("一个元素").findFirst());test(Stream.<String>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<String> optString) {if (optString.isPresent())System.out.println(optString.get());elseSystem.out.println("流中不存在数据");}static void ifPresent(Optional<String> optString) {optString.ifPresent(System.out::println);}static void orElse(Optional<String> optString) {System.out.println(optString.orElse("从orElse()返回的对象"));}static void orElseGet(Optional<String> optString) {System.out.println(optString.orElseGet(() -> "orElseGet()替换的对象"));}static void orElseThrow(Optional<String> 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<Optional<String>> cos) { // 一个可以接收所有示例方法的Consumer,避免代码重复System.out.println(" === " + testName + " === ");cos.accept(Stream.of("测试语句").findFirst());cos.accept(Stream.<String>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<String> 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<String> testStream() {return Arrays.stream(elements);}static void test(String descr, Predicate<String> 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<String> testStream() {return Arrays.stream(elements);}static void test(String descr,Function<String, String> 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<String> testStream() {return Arrays.stream(elements);}static void test(String descr,Function<String, Optional<String>> func) { // Function的返回类型是Optional<String>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;}@Overridepublic 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<Optional<Signal>> 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的流中提取对象时,往往会遇到“没有值”的情况。这就需要我们针对不同的应用采取不同的方法。