Java 8 Stream API的使用示例

前言

Java Stream API借助于Lambda表达式，为Collection操作提供了一个新的选择。如果使用得当，可以极大地提高编程效率和代码可读性。

本文将介绍Stream API包含的方法，并通过示例详细展示其用法。

---

一、Stream特点

Stream不是集合元素，它不是数据结构也不保存数据，而更像一个高级版本的迭代器(Iterator)。Stream操作可以像链条一样排列，形成Stream Pipeline，即链式操作。

Stream Pipeline由数据源的零或多个中间(Intermediate)操作和一个终端(Terminal)操作组成。中间操作都以某种方式进行流数据转换，将一个流转换为另一个流，转换后元素类型可能与输入流相同或不同，例如将元素按函数映射到其他类型或过滤掉不满足条件的元素。 终端操作对流执行最终计算，例如将其元素存储到集合中、遍历打印元素等。

Stream特点：

• 无存储。Stream不是一种数据结构，也不保存数据，数据源可以是一个数组，Java容器或I/O Channel等。

• 为函数式编程而生。对Stream的任何修改都不会修改数据源，例如对Stream过滤操作不会删除被过滤的元素，而是产生一个不包含被过滤元素的新Stream。

• 惰性执行。Stream上的中间操作并不会立即执行，只有等到用户真正需要结果时才会执行。

• 一次消费。Stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。

注意：没有终端操作的流管道是静默无操作的，所以不要忘记包含一个终端操作。

二、用法示例

以下将基于《Java 8 Optional类使用的实践经验》一文中的Person类，展示Stream API的用法。考虑到代码简洁度，示例中尽量使用方法引用。

2.1 Stream创建

2.1.1 通过参数序列创建Stream

对于可变参数序列，通过Stream.of()创建Stream，而不必先创建Array再创建Stream。

IntStream stream = IntStream.of(10, 20, 30, 40, 50); // 不要使用Stream<Integer>
Stream<String> colorStream = Stream.of("Red", "Pink", "Purple");
Stream<Person> personStream = Stream.of(
        new Person("mike", "male", 10),
        new Person("lucy", "female", 4),
        new Person("jason", "male", 5)
);

2.1.2 通过数组创建Stream

不用区分基础数据类型，但参数只能是数组。

int[] intNumbers = {10, 20, 30, 40, 50};
IntStream stream = IntStream.of(intNumbers);

2.1.3 通过集合(Collection子类)创建Stream

调用parallelStream()或stream().parallel()方法可创建并行Stream。

Stream<Integer> numberStream = Arrays.asList(10, 20, 30, 40, 50).stream();

2.1.4 通过生成器创建Stream

· 通常用于随机数、元素满足固定规则的Stream，或用于生成海量测试数据的场景。

· 应配合limit()、filter()使用，以控制Stream大小，否则stream长度无限。

Stream.generate(Math::random).limit(10)
Stream.generate(() -> (int) (System.nanoTime() % 100)).limit(5)

2.1.5 通过iterate创建Stream

· 重复对给定种子值(seed)调用指定的函数来创建Stream，其元素为seed, f(seed), f(f(seed))...无限循环。

· 通常用于随机数、元素满足固定规则的Stream，或用于生成海量测试数据的场景。

· 应配合limit()、filter()使用，以控制Stream大小，否则stream长度无限。

// 按行依次输出：0、5、10、15、20
Stream.iterate(0, n -> n + 5).limit(5).forEach(System.out::println);

2.1.6 通过区间创建整数序列Stream

用于IntStream、LongStream，range()不包含尾元素，rangeClosed()包含尾元素。

LongStream longRange = LongStream.range(-100L, 100L); // 生成[-100, 100)区间的元素序列

2.1.7 通过IO方式创建Stream

· 适用于从文本文件中逐行读取数据、遍历文件目录等场景。

· 通常配合try ... with resources语法使用，以安全而简洁地关闭资源。

try (Stream<String> lines = Files.lines(Paths.get("./file.txt"), StandardCharsets.UTF_8)) {
            // 跳过第一行，输出第2~4共计三行
            lines.skip(1).limit(3).forEach(System.out::println);
        } catch (IOException e){
            System.out.println("Oops!");
        }

2.2 Stream操作

常见的操作可以归类如下：

Intermediate：Stream经过此类操作后，结果仍为Stream

map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

Terminal：Stream里包含的内容按照某种算法汇聚为一个值

forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

基本的Stream用法格式为Stream.Intermediate.Terminal(SIT)。Java8特性详解 lambda表达式 Stream以图示形式直观描述了这种格式及若干Intermediate操作。

本节主要介绍常用操作及代码示例。为便于演示，首先定义如下集合对象：

List<Person> persons = Arrays.asList(
        new Person("mike", "male", 10).setLocation("China", "Nanjing"),
        new Person("lucy", "female", 4),
        new Person("jason", "male", 5).setLocation("China", "Xian")
);

2.2.1 map + sum + filter + reduce

只有IntStream、LongStream和DoubleStream支持sum()方法。

// 计算年龄总和：totalAge = 19
int totalAge = persons.stream().mapToInt(Person::getAge).sum();
// 并行计算年龄总和，此处不建议使用reduce(针对复杂的规约操作)
persons.stream().parallel().mapToInt(Person::getAge).reduce(0, Integer::sum);
// 计算男生年龄总和：totalAge = 15
persons.stream().filter(person -> "male".equals(person.getGender())).mapToInt(Person::getAge).sum();

2.2.2 map + average + max

average()返回OptionalDouble，max()/min()返回OptionalInt或Optional。

// 计算年龄均值，输出6.333333333333333
persons.stream().mapToInt(Person::getAge).average().ifPresent(System.out::println);
// 计算字典序最大的人名，输出mike
persons.stream().map(Person::getName).max(String::compareToIgnoreCase).ifPresent(System.out::println);

2.2.3 map + forEach

// 输出每个学生姓名的大写形式，按行输出：MIKE、LUCY、JASON
persons.stream()
        .map(Person::getName) // 将Person对象映射为String（姓名）
        .map(String::toUpperCase) // 将姓名转换大写
        .forEach(System.out::println); // 按行输出List元素

2.2.4 collect

· collect操作可将Stream元素转换为不同的数据类型，如字符串、List、Set和Map等。

· Java 8通过Collectors类支持各种内置收集器，以简化collect操作。

// 得到字符串：Colors: Red&Pink&Purple!
colorStream.collect(Collectors.joining("&", "Colors: ", "!"));
// 得到ArrayList，元素为：Red, Pink, Purple
// 注意，Stream转换为数组的格式形如stream.toArray(String[]::new)
colorStream.collect(Collectors.toList());
// 得到HashSet，元素为：Red, Pink, Purple
colorStream.collect(Collectors.toSet());
// 得到LinkedList，toCollection()用于指定集合类型
colorStream.collect(Collectors.toCollection(LinkedList::new));
// 得到HashMap，{mike=Person{name='mike'}, jason=Person{name='jason'}, lucy=Person{name='lucy'}}
personStream.collect(Collectors.toMap(Person::getName, Function.identity()));

collect收集器还提供summingInt()、averagingInt()和summarizingInt()等计算方法。

// 返回流中整数属性求和，即19
persons.stream().collect(Collectors.summingInt(Person::getAge))
// 计算流中Integer属性的平均值，即6.333333333333333
persons.stream().collect(Collectors.averagingInt(Person::getAge))
// 收集流中Integer属性的统计值，即IntSummaryStatistics{count=3, sum=19, min=4, average=6.333333, max=10}
persons.stream().collect(Collectors.summarizingInt(Person::getAge))

2.2.5 sorted + collect

// 按照年龄升序排序：sortedpersons = [Person{name='lucy'}, Person{name='jason'}, Person{name='mike'}]
List<Person> sortedPersons = persons.stream()
        .sorted(Comparator.comparingInt(Person::getAge)) // 按照年龄排序
        .collect(Collectors.toList()); // 汇聚为一个List对象
// 按照姓名长度升序排序，按行输出：mike: 4、lucy: 4、jason: 5
persons.stream()
        .sorted(Comparator.comparingInt(p -> p.getName().length()))
        .map(Person::getName)
        .map(name -> name + ": " + name.length())
        .forEach(System.out::println);

2.2.6 map + anyMatch

// 判断是否存在名为jason的人：existed = true
boolean existed = persons.stream()
        .map(Person::getName)
        .anyMatch("jason"::equals); // 任意匹配项是否存在

2.2.7 groupingBy + map + reduce

// 将所有人按照性别分组并计数，输出：{female=1, male=2}
Map<String, Long> groupBySex = persons.stream().collect(groupingBy(Person::getGender, counting()));
System.out.println(groupBySex);
// 将所有人按照性别分组并计算各组最大年龄，输出：Person{name='mike'}
Map<String, Optional<Person>> groupBySexAge = persons.stream().collect(
        groupingBy(Person::getGender, maxBy(Comparator.comparingInt(Person::getAge))));
System.out.println(groupBySexAge.get("male").get());
// 将所有人按照性别分组，按行输出：female: lucy、male: mike,jason
persons.stream().collect(groupingBy(Person::getGender))
        .forEach((k, v) ->System.out.println(k + ": "
                + v.stream().map(Person::getName)
                .reduce((x, y) -> x + "," + y).get()));

注意，本例采用import static java.util.stream.Collectors.*;这种静态导入的方式简化Collectors.groupingBy()的调用，代码更简洁易读。此外，不推荐示例中forEach()的用法。

2.2.8 maps + collect

// 计算身高比例分布：agePercentages = [52.63%, 21.05%, 26.32%]
List<String> agePercentages = persons.stream()
        .mapToInt(Person::getAge) // 将Person对象映射为年龄整型值
        .mapToDouble(age -> age / (double)totalAge * 100) // 计算年龄比例
        .mapToObj(new DecimalFormat("##.00")::format) // DoubleStream -> Stream<String>
        .map(percentage -> percentage + "%") // 添加百分比后缀

        .collect(Collectors.toList());
// 若元素数目较多，可先定义formator = new DecimalFormat("##.00")，再调用mapToObj(formator::format)

2.2.9 flatMap

flatMap()将Stream中的集合实例内的元素全部拍平铺开，形成一个新的Stream，从而到达合并的效果。

// 传统写法（注意两层循环）
private static int countPrefix(List<List<String>> nested, String prefix) {
    int count = 0;
    for (List<String> element : nested) {
        if (element != null) {
            for (String str : element) {
                if (str.startsWith(prefix)) {
                    count++;
                }
            }
        }
    }
    return count;
}
// Stream写法
private static int countPrefixWithStream(List<List<String>> nested, String prefix) {
    return (int) nested.stream()
            .filter(Objects::nonNull)
            .flatMap(Collection::stream)
            .filter(str -> str.startsWith(prefix))
            .count();
}

List<List<String>> lists = Arrays.asList(
        Arrays.asList("Jame"),
        Arrays.asList("Mike", "Jason"),
        Arrays.asList("Jean", "Lucy", "Beth")
);
System.out.println("以J开头的人名数：" + countPrefixWithStream(lists, "J"));

三、规则总结

使用Stream时，需注意以下规则：

1. 避免重用Stream。

   Java 8 Stream一旦被Terminal操作消费，将不能够再使用，必须为待执行的每个Terminal操作创建新的Stream链。在实际开发时，将共用的Stream实例定义为成员变量时，尤其容易犯错。

   重用Stream将报告stream has already been operated upon or closed的异常。

   若需要多次调用，可利用Stream Supplier实例来创建已构建所有中间操作的新Stream。例如：

   Supplier<Stream<String>> streamSupplier =
           () -> Stream.of("d2", "a2", "b1", "b3", "c")
                   .filter(s -> s.startsWith("a"));
   streamSupplier.get().anyMatch(s -> true);   // 每次调用get()构造一个新stream
   streamSupplier.get().noneMatch(s -> true);
   

   注意，anyMatch()方法接受Predicate引元，通常无需使用filter，此处仅为示例方便。

2. 避免创建无限流。

   通过iterate或生成器创建Stream时，应配合limit()使用，以控制Stream大小。

   但distinct()与limit()共用时，应特别注意去重后元素数目是否满足limit限制。例如：

   IntStream.iterate(0, i -> (i + 1) % 2) // 生成0和1的整数序列
       .distinct() // 去重后为0和1两个元素
       .limit(10) // limit(10)限制得不到满足，从而变成无限流
       .forEach(System.out::println);
   

3. 注意Stream操作顺序，尽可能提前通过filter()等操作降低数据规模。

   以下面一段简单的代码为例：

   Stream.of("a1", "b2", "c3", "d4", "e5").map(s -> {
       System.out.println("map: " + s);
       return s.toUpperCase();
   }).filter(s -> {
       System.out.println("filter: " + s);
       return s.startsWith("A");
   }).forEach(s -> System.out.println("forEach: " + s));
   

   运行输出如下：

   map: a1
   filter: A1
   forEach: A1
   map: b2
   filter: B2
   map: c3
   filter: C3
   map: d4
   filter: D4
   map: e5
   filter: E5
   

   可见，流中的每个字符串都被调用5次map()和filter()，而forEach()只调用一次。

   再改变操作顺序，将filter()移到Stream操作链的头部：

   Stream.of("a1", "b2", "c3", "d4", "e5").filter(s -> {
       System.out.println("filter: " + s);
       return s.startsWith("a");
   }).map(s -> {
       System.out.println("map: " + s);
       return s.toUpperCase();
   }).forEach(s -> System.out.println("forEach: " + s));
   

   运行输出如下：

   filter: a1
   map: a1
   forEach: A1
   filter: b2
   filter: c3
   filter: d4
   filter: e5
   

   可见，map()只被调用一次。虽然Stream惰性计算的特性使得操作顺序并不影响最终结果，但合理地安排顺序可以减少实际执行次数。数据规模较大时，性能会有较明显的提升。

4. 注意Stream操作的副作用。

   大多数Stream操作必须是无干扰、无状态的。

   “无干扰”是指在流操作的过程中，不去修改流的底层数据源。例如，遍历流时不能通过添加或删除集合中的元素来修改集合。

   “无状态”是指Lambda表达式的结果不能依赖于流管道执行过程中，可能发生变化的外部作用域的任何可变变量或状态。

   以下代码试图在操作流时添加和移出元素，运行时均会抛出java.util.ConcurrentModificationException异常：

   List<String> strings = new ArrayList<>(Arrays.asList("one", "two"));
   String concatenatedString = strings.stream()
           // 不要这样做，干扰发生在这里
           .peek(s -> strings.add("three"))
           .reduce((a, b) -> a + " " + b)
           .get();
   List<Integer> list = IntStream.range(0, 10)
           .boxed() // 流元素装箱为Integer类型
           .collect(Collectors.toCollection(ArrayList::new));
   list.stream()
           .peek(list::remove) // 不要这样做，干扰发生在这里
           .forEach(System.out::println);
   

   以下代码对并行Stream使用了有状态的Lambda表达式：

   Integer[] intArray = {1, 2, 3, 4, 5, 6, 7, 8};
   List<Integer> listOfIntegers = new ArrayList<>(Arrays.asList(intArray));
   List<Integer> parallelStorage = new ArrayList<>();
   //List<Integer> parallelStorage = Collections.synchronizedList(new ArrayList<>());
   listOfIntegers.parallelStream()
           // 不要这样做，此处使用了有状态的Lambda表达式
           .map(e -> { parallelStorage.add(e); return e; })
           .forEachOrdered(e -> System.out.print(e + " "));
   System.out.println(": 1st");
   parallelStorage.stream().forEachOrdered(e -> System.out.print(e + " "));
   System.out.println(": 2nd");
   

   运行结果可能出现以下几种：

   // 并行执行流时，map()添加元素的顺序和随后的forEachOrdered()元素打印顺序不同
   1 2 3 4 5 6 7 8 : 1st
   1 6 3 2 7 8 5 4 : 2nd
   // 多线程可能同时读取到相同的下标n进行赋值，导致元素数量少于预期（采用synchronizedList可解决该问题）
   1 2 3 4 5 6 7 8 : 1st
   1 5 8 3 6 : 2nd
   

   《Effective Java 第三版》中指出，不要尝试并行化流管道，除非有充分的理由相信它将保持计算的正确性并提高其速度。 不恰当地并行化流的代价可能是程序失败或性能灾难。

5. 避免过度使用Stream，否则可能使代码难以阅读和维护。

   常见的问题是Lambda表达式过长，可通过抽取方法等手段，尽量将Lambda表达式限制在几行之内。