初识Java 12-1 流

目录

Java 8对流的支持

流的创建

随机数流

int类型的区间范围

generate()

iterate()

流生成器

Arrays

正则表达式

---

本笔记参考自： 《On Java 中文版》

---

||| 流的概念：流是一个与任何特定的存储机制都没有关系的元素序列。

        流与对象的成批处理有关。使用流的时候，我们会从一个管道（Pipe，这一概念主要用于不同线程之间的通信）中抽取元素，并对它们进行操作。

    这些管道通常会被串联起来，形成这个流上的一个操作管线。

        流的一个核心优点是，它们能使我们的程序更小，也更好理解。而当配合流进行使用时，lambda表达式和方法引用能更好的发挥它们的作用。

【例子：以有序方式显示int数】

        在该例子中，需要按照有序方式显示随机选择的5~20范围内、不重复的int数。

import java.util.Random;

public class Randoms {
    public static void main(String[] args) {
        new Random(47)
                .ints(5, 20) // 生成一个ints类型的流，范围是5~20
                .distinct() // 中间流操作distinct()：去除重复的值
                .limit(7) // 选择前7个值
                .sorted() // 进行排序
                .forEach(System.out::println); // 为每一个流元素执行括号中的操作
    }
}

        程序执行的结果如下：

        ints()方法会生成一个流，该方法有多个重载版本，其中两个元素的版本可以设置所生成值的上下界。

        注意：Randoms.java没有声明任何变量。流可以对有状态的系统进行建模，而不需要使用赋值或可变数据（在之后的例子中这种做法会经常见到）。

    上述这个例子展示了一种编程风格：声明式编程。我们说明想要完成什么（what），而不是指名怎么做（how）。

        上述例子的命令式编程形式如下，这种形式更难理解：

        这种形式需要定义3个变量，并且由于nextInt()无法确定下界，因此需要我们手动进行设定。这就体现了Randoms.java这种写法的优势：方便，并且表达清晰。

        还可以这样区分上述这两个示例：

• 外部迭代：像ImperativeRandoms.java这样显式地编写的迭代机制。
• 内部迭代：像Randoms.java这样，我们看不见任何迭代机制。这种迭代产生的代码具有更好的可读性，并且更适用于多处理器。

        除此之外，流还有一个重要特性：惰性求值。这意味着它们只有在绝对必要时才会被求值（通常是在表达式的值被使用时）。这种延迟求值的特性，使得我们可以表示非常大的序列，而不用考虑内存问题。

Java 8对流的支持

        早期的Java并没有引入流的概念。这使得在后来，当Java的设计者想要引入流的概念时，面对的是一整套现有的库。若想要将流这个概念融入Java，就需要向接口中放入新的方法，这无疑会破坏原有的结构。

        Java 8引入的解决方案是接口中的默认（default）方法。使用它，Java的设计者们将流方法硬塞进了现有的类中（并且放入的操作还不少）。现在，可以将Java中的流操作分为三种类型：

1. 创建流。
2. 修改流元素（即中间操作）。
3. 消费流元素（即终结操作），这种操作往往意味着收集一个流的元素（通常会将收集的元素放入一个集合中）。

流的创建

【例子：Stream.of()的使用例】

import java.util.stream.Stream;

public class StreamOf {
    public static void main(String[] args) {
        Stream.of( // 在这里，构造器Bubble()只是用于生成一个普通的类
                        new Bubble(1), new Bubble(2), new Bubble(3))
                .forEach(System.out::println);

        Stream.of("八百", "标兵", "奔", "北坡")
                .forEach(System.out::print);

        System.out.println();
        Stream.of(3.14159, 2.718, 1.618)
                .forEach(System.out::println);
    }
}

        程序执行的结果如下：

        通过使用Stream.of()，可以轻松地将一组条目变为一个流。

        另外，Collection也包含了一个stream()操作，通过它，可以生成一个基于Collection的流：

【例子：通过Collection生成一个流】

import java.util.*;

public class CollectionToStream {
    public static void main(String[] args) {
        List<Bubble> bubbles = Arrays.asList(
                new Bubble(1), new Bubble(2), new Bubble(3));
        System.out.println(
                bubbles.stream() // 通过Collection生成一个流
                        .mapToInt(b -> b.i) // 将对象流转变成一个包含Integer的IntStream
                        .sum());

        Set<String> w = new HashSet<>(Arrays.asList(
                "G F E D C B A".split(" ")
        ));
        // map()操作会接受流中的每个元素，在其上应用括号中的操作来创建一个新的元素（这个新元素会继续顺着流传递下去）
        w.stream()
                .map(x -> x + " ")
                .forEach(System.out::print);

        System.out.println();
        Map<String, Double> m = new HashMap<>();
        m.put("pi", 3.14159);
        m.put("e", 2.718);
        m.put("phi", 1.618);
        m.entrySet().stream()
                .map(e -> e.getKey() + ": " + e.getValue())
                .forEach(System.out::println);
    }
}

        程序执行的结果是：

        map()方法接受流中的每个元素，在其上应用一个操作来创建一个新的元素，然后将这个新元素沿着流继续传递下去。map()有许多不同的版本，比如mapToInt()等。

    所有集合类都有stream()方法。

        为了从Map集合中生成一个流，需要首先调用entrySet()来生成一个对象流（其中的每个对象都包含一个键和与其相关联的值）。

随机数流

        就像之前示例所示，Random类在Java 8时得到了增强，它获得了一组可以生成流的方法：

【例子：Random类的stream()方法使用（以int类型为例）】

import java.util.Random;
import java.util.stream.Stream;

public class RandomGenerators {
    public static <T> void show(Stream<T> stream) {
        stream
                .limit(4)
                .forEach(System.out::println);
        System.out.println("++++++++");
    }

    public static void main(String[] args) {
        Random rand = new Random(47);

        System.out.format("%n无参数时：%n");
        show(rand.ints().boxed()); // boxed()方法可以将基本类型转换为对应的包装器类型

        // 一个参数：控制流的大小
        System.out.format("%n一个参数时：%n");
        show(rand.ints(2).boxed());

        // 两个参数：控制上下边界
        System.out.format("%n两个参数时：%n");
        show(rand.ints(10, 20).boxed());

        // 三个参数：控制流的大小和边界
        System.out.format("%n三个参数时：%n");
        show(rand.ints(3, 3, 9).boxed());
    }
}

        程序执行的结果是：

        其他类型也有可以通过类型的方式创建流。

        在上述程序中出现了这样的语句：

public static <T> void show(Stream<T> stream) {

其中，类型参数T可以是任何东西，因此可以使用Integer（Long或者Double等）。另外，虽然Random类只会生成int、double之类的基本类型的值。但boxed()流会自动将基本类型转换为其对应的包装器类型。

        使用Random，也可以创建一个可用于提供任何一组对象的Supplier。

【例子：使用Random创建Supplier】

        要求：读取以下文本文件（Cheese.dat），生成String对象。

Not much of a cheese shop really, is it?
Finest in the district, sir.
And what leads you to that conclusion?
Well, it's so clean.
It's certainly uncontaminated by cheese.

        编写程序，通过File类读取文本：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class RandomWords implements Supplier<String> {
    List<String> words = new ArrayList<>();
    Random rand = new Random(47);

    RandomWords(String fname) throws IOException { // throws：声明一个方法可能抛出的异常
        List<String> lines = Files.readAllLines(Paths.get(fname));

        // 使用的是外部迭代（可优化）
        for (String line : lines.subList(1, lines.size())) { // subList()方法用于去除第一行
            for (String word : line.split("[ .?,]+"))
                words.add(word.toLowerCase());
        }
    }

    @Override
    public String get() {
        return words.get(rand.nextInt(words.size()));
    }

    @Override
    public String toString() {
        return words.stream().collect(Collectors.joining(" "));
    }

    public static void main(String[] args) throws Exception {
        System.out.println(
                Stream.generate(
                                new RandomWords("Cheese.dat"))
                        .limit(10)
                        .collect(Collectors.joining(" "))
        );
    }
}

        程序执行的结果是：

        上述语句出现中，split()方法的表达式变得更加复杂了。

line.split("[ .?,]+")

这条语句会在遇见 ①空格 或 ②方括号内存在的标点符号 时进行分隔。另外，方括号右边的+表示其前面出现的事物是可以重复出现的。

        在toString()和main()中都出现了collect()操作，这一操作会根据参数将所有的流元素组合起来。当向collect()中传入一个Collectors.joining()时，得到的结果是一个String，它会根据joining()中的参数进行分隔。

    除上面演示的之外，还存在着许多的Collectors。

        注意Stream.generate()，它可以接受任何的Supplier<T>，并生成一个由T类型的对象组成的流（这个流的长度可以看做无限长）。

---

int类型的区间范围

        IntStream类提供了一个range()方法，可以生成一个由int值组成的流：

【例子：IntStream中的range()方法】

import static java.util.stream.IntStream.*;

public class Ranges {
    public static void main(String[] args) {
        // 传统方式：生成一个int值组成的序列
        int result = 0;
        for (int i = 10; i < 20; i++)
            result += i;
        System.out.println(result);

        // for-in搭配一个区间范围
        result = 0;
        for (int i : range(10, 20).toArray())
            result += i;
        System.out.println(result);

        // 使用流
        System.out.println(range(10, 20).sum());
    }
}

        程序执行的结果如下：

        可以看出，使用流的第三种方法更加简便。

        另外，可以使用repeat()工具函数来取代简单的for循环：

【例子：repeat()方法及其使用例】

package onjava;

import static java.util.stream.IntStream.*;

public class Repeat {
    public static void repeat(int n, Runnable action) {
        range(0, n).forEach(i -> action.run());
    }
}

        使循环变得更加简洁：

import static onjava.Repeat.*;

public class Looping {
    static void hi() {
        System.out.println("嗨!");
    }

    public static void main(String[] args) {
        repeat(3, ()->System.out.println("循环中..."));
        repeat(2, Looping::hi);
    }
}

        程序执行的结果是：

---

generate()

        再来看一个generate()方法的使用例：

【例子：generate()方法的使用例】

import java.util.Random;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Generator implements Supplier<String> {
    Random rand = new Random(47);
    char[] letters = "ABCDEFGHIJKLMN".toCharArray();

    @Override
    public String get() {
        return "" + letters[rand.nextInt(letters.length)];
    }

    public static void main(String[] args) {
        String word = Stream.generate(new Generator())
                .limit(30) // 选择前30个值
                .collect(Collectors.joining()); // collect()在后台最终会调用Supplier<>的get()（可查看堆栈）
        System.out.println(word);
    }
}

        程序执行的结果是：

        在官方文档中，有关于generate()的说明：

这个方法会返回一个无限的、连续的并且没有顺序的流，其中的每个元素有Supplier生成。

        若想要创建一个由完全相同的对象组成的流，只需要将一个生成这些对象的lambda表达式传递给generate()即可：

import java.util.stream.Stream;

public class Duplicator {
    public static void main(String[] args) {
        Stream.generate(() -> "duplicate")
                .limit(3)
                .forEach(System.out::println);
    }
}

        程序执行的结果是：

        Java会根据我们传入的lambda表达式（方法引用也是），在底层创建一个实现了目标接口的类的示例。因此generate()可以接受一个lambda表达式。

    复习：Supplier是一个函数式接口。

        接下来展示的是之前提到过的Bubble类，它包含了自己的静态生成器方法：

public class Bubble {
    public final int i;

    public Bubble(int n) {
        i = n;
    }

    @Override
    public String toString() {
        return "Bubble(" + i + ")";
    }

    private static int count = 0;

    public static Bubble bubbler() {
        return new Bubble(count++);
    }
}

        在这里，bubbler()方法能够与Supplier<Bubble>接口相兼容，理由如下（参考讯飞星火）：

• bubbler()方法是静态的（可用于静态方法引用），并且返回类型是Bubble。
• 无参，与Supplier<Bubble>的无参构造器相匹配。
• bubbler()的设计目的与Supplier<Bubble>的相符合，即提供一个无参数的工厂方法来生成特定类型的对象。

因此可以将该方法引用传递给Stream.generate()：

import java.util.stream.Stream;

public class Bubbles {
    public static void main(String[] args) {
        Stream.generate(Bubble::bubbler)
                .limit(5)
                .forEach(System.out::println);
    }
}

        程序执行的结果是：

        这是创建一个单独的工厂方法的一个替代方案。

---

iterate()

        Stream.iterate()的官方描述是这样的：

这个方法会从第一个种子（seed，即第一个参数）开始，将其传递给第二个参数所引用的方法。方法的结果会被添加到这个流上，并被保存下来作为下一次iterate()调用的第一个参数，以此类推。

    iterate()方法还有一个3参数的版本，多了一个用于筛选的谓词（Predicate）。

【例子：斐波那契数列】

import java.util.stream.Stream;

public class Fibonacci {
    int x = 1;

    Stream<Integer> numbers() {
        return Stream.iterate(0, // 0被传递给i，作为i的初始值
                i -> { // i中储存的是return语句的返回值
                    int result = x + i;
                    x = i; // 需要使用一个x来保存另一个数值
                    return result;
                });
    }

    public static void main(String[] args) {
        new Fibonacci().numbers()
                .skip(20) // 跳过前20个数据
                .limit(10) // 然后再从中取出前10个
                .forEach(System.out::println);
    }
}

        程序执行的结果是：

        斐波那契数列将数列中的最后两个元素相加，生成下一个元素。由于iterate()只会记住结果（result），因此需要使用x来记住另一个元素。

---

流生成器

        在生成器（Builder）设计模式中，我们会创建一个生成器对象，为该对象提供多段构造信息，最终执行“生成”动作。Stream库提供了这样一个Builder：

【例子：Builder的使用例】

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class FileToWordsBuilder {
    Stream.Builder<String> builder = Stream.builder();

    public FileToWordsBuilder(String filePath) 
            throws Exception {
        Files.lines(Paths.get(filePath))
                .skip(1) // 跳过开头行
                .forEach(line -> {
                    for (String w : line.split("[ .?,]+"))
                        builder.add(w); // 从文件中读取的数据需要被分解成流中的一个个元素
                });
    }

    Stream<String> stream() {
        return builder.build();
    }

    public static void main(String[] args) throws Exception {
        new FileToWordsBuilder("Cheese.dat").stream() // 若Cheese.dat不在当前文件夹中，可使用绝对路径等进行指引
                .limit(7)
                .map(w -> w + " ")
                .forEach(System.out::print);
    }
}

        程序执行的结果是：

        注意，在构造器添加文件中的单词时，它没有调用build()。这意味着，只要不调用stream()方法，就可以继续往builder对象中添加单词。

    可以加入一个标志来查看build()是否已经被调用，加入一个方法在可能的情况下继续添加单词。

---

Arrays

        Arrays类中同样包含了名为stream()的静态方法，可以将数组转换成流。

【例子：Arrays的stream()】

import java.util.Arrays;
import onjava.Operation;

public class MetalWork2 {
    public static void main(String[] args) {
        Arrays.stream(new Operation[]{
                () -> Operation.show("Heat"),
                () -> Operation.show("Hammer"),
                () -> Operation.show("Twist"),
                () -> Operation.show("Anneal"),
        }).forEach(Operation::execute); // execute负责执行流中每个元素对应的操作
    }
}

        程序执行的结果是：

        上述例子中出现的Operation接口定义如下：

这是一个函数式接口，定义了show()方法和runOps()方法。

        new Operation[]表达式动态地创建了一个由Operation对象组成的类型化数组。forEach()操作会为数组中的每一个元素执行execute()。也就是说，在没有进入这条ForEach()操作之前，都可以继续往Operation[]中添加内容。

        使用stream()方法也可以生成IntStream、LongStream和DoubleStream：

【例子：stream()方法生成其他Stream】

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayStreams {
    public static void main(String[] args) {
        Arrays.stream(
                        new double[]{3.14159, 2.718, 1.618})
                .forEach(n -> System.out.format("%f ", n));
        System.out.println();
        
        Arrays.stream(new int[]{1, 3, 5})
                .forEach(n -> System.out.format("%d ", n));
        System.out.println();
        
        Arrays.stream(new long[]{11, 22, 33, 44})
                .forEach(n -> System.out.format("%d ", n));
        System.out.println();
        
        // 选择一个子区间：
        Arrays.stream(
                new int[]{1, 3, 5, 7, 15, 28, 37}, 3, 6)
                .forEach(n->System.out.format("%d ", n));
        System.out.println();
    }
}

        程序执行的结果是：

        最后出现的语句

(new int[]{1, 3, 5, 7, 15, 28, 37}, 3, 6)

多使用了两个额外的参数：第一个参数告诉stream()从数组哪个位置开始选择元素，第二个参数告诉stream()在哪里停下。

---

正则表达式

        Java 8向java.util.regex.Patern类中加入了一个新方法：splitAsStream()。这个新方法接受一个字符序列，并根据我们传入的公式将其分割为一个流。

    splitAsStream()有一个约束，其输入应该是一个CharSequence，因此我们不能将一个流传入到splitAsStream()中。

【例子：利用正则表达式切割String】

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class FileToWordsRegexp {
    private String all;

    public FileToWordsRegexp(String filepath)
            throws Exception {
        all = Files.lines(Paths.get(filepath))
                .skip(1) // 跳过第一行
                .collect(Collectors.joining(" "));
    }

    public Stream<String> stream() {
        return Pattern.compile("[ ,.?]+").splitAsStream(all);
    }

    public static void main(String[] args)
            throws Exception {
        FileToWordsRegexp fw = new FileToWordsRegexp("Cheese.dat");
        fw.stream()
                .limit(7)
                .map(w -> w + " ")
                .forEach(System.out::print);
        System.out.println();

        fw.stream()
                .skip(7)
                .limit(2)
                .map(w -> w + " ")
                .forEach(System.out::print);
        System.out.println();
    }
}

        程序执行的结果是：

        构造器读取了文件中的信息，将其转入一个String中。在这里，我们可以多次回头调用stream()，并且每次都可以从保存的String中创建一个新的流。

        这个例子存在一个缺点：被读取的整个文件都要存储在内存中。这会导致流的两个优势（占据极少的内部存储，以及惰性求值）无法发挥其的作用。