初识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<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), // 其中的每一个流的长度不超过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<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()：若存在值，返回true
            System.out.println(optString.get());
        else
            System.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());
        else
            System.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;
    }

    @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<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);
    }
}

程序执行的结果如下：