Java 8 Stream 知识分享

作者: 巴掌大叔 | 来源:发表于2022-04-26 10:51 被阅读0次

综述

Java 8 新增了 Stream API。Stream API有点类似使用SQL 语句，可以将集合中的元素进行过滤。使用时，类似于从一个管道中抽取元素，并对他们进行操作。使用流的一个优点是，他可以使得我们的程序更小，并且更容易理解。

与Stream API相关的接口有Stream、IntStream, LongStream, DoubleStream（因为 Java 的泛型不支持基本数据类型，而又因频繁的装箱、拆箱存在效率问题，故额外有后三者）。

使用Stream操作时，我们通常使用链式操作，即将多条代码合并成一条代码（事例将在使用Supplier创建中给出）。

Java Collection 体系数据处理的演进

本小节用于测试的代码如下：

public record User(Integer id, String name, Integer money) { }

final var users = Arrays.asList(
      new User(1, "张三", 200),
      new User(2, "李四", 200),
      new User(3, "王五", 10000),
      new User(4, "赵六", 20000),
      new User(5, "王强", 80000)
);

通过不同方法来过滤不同数据

我们过滤数据首先想到的方法是针对各个需求来定义一个个的方法。

例如，产品经理给了你一个筛选出所有 id 大于 3 用户的需求，可以定义如下getIdGreaterThan3的方法。

public class CollectionStream {
    public static void main(String[] args) {
        // users 定义
        final var newUsers = getIdGreaterThan3(users);
        for (User user : newUsers) {
            System.out.println(user);
        }
    }
    public static List<User> getIdGreaterThan3(List<User> users) {
        final var newUsers = new ArrayList<User>();
        for (User user : users) {
            if (user.id() > 3) {
                newUsers.add(user);
            }
        }
        return newUsers;
    }
}

/*
  输出：
  User[id=4, name=赵六, money=20000]
  User[id=5, name=王强, money=80000]
*/

第二天，产品经理要求你筛选出所有姓“王”的用户的需求，定义getAllWang方法：

public class CollectionStream {
    public static void main(String[] args) {
        // users 定义
        final var newUsers = getAllWang(users);
        for (User user : newUsers) {
            System.out.println(user);
        }
    }
    public static List<User> getAllWang(List<User> users) {
        final var newUsers = new ArrayList<User>();
        for (User user : users) {
            if (user.name().startsWith("王")) {
                newUsers.add(user);
            }
        }
        return newUsers;
    }
}

/*
  输出：
  User[id=3, name=王五, money=10000]
  User[id=5, name=王强, money=80000]
*/

第三天，产品经理要求你开发所有钱大于 10000 的用户的需求，你瞅了瞅他，写出了如下代码：

public class CollectionStream {
    public static void main(String[] args) {
        // users 定义
        final var newUsers = getRichPeople(users);
        for (User user : newUsers) {
            System.out.println(user);
        }
    }
    public static List<User> getRichPeople(List<User> users) {
        final var newUsers = new ArrayList<User>();
        for (User user : users) {
            if (user.money() > 10000) {
                newUsers.add(user);
            }
        }
        return newUsers;
    }
}

/*
  输出：
  User[id=4, name=赵六, money=20000]
  User[id=5, name=王强, money=80000]
*/

此时此刻，你会发现我们似乎写了很多重复的方法...

使用接口来代替重复操作

在 Java 世界中，对于相似的操作我们通常使用接口定义，对于不同的操作我们相应的定义不同的实现类来实现不同的功能。

public class CollectionStream {
    public static void main(String[] args) {
        // users 定义
        for (User user : getUsers(users, new JudgeIdGreaterThan3())) {
            // 判断ID是否大于3
            System.out.println(user);
        }

        for (User user : getUsers(users, new JudgeIsWang())) {
            // 判断是否姓王
            System.out.println(user);
        }

        for (User user : getUsers(users, new JudgeIsRich())) {
            // 判断是否有钱
            System.out.println(user);
        }
    }

    public static List<User> getUsers(List<User> users, Judge condition) {
        final var newUsers = new ArrayList<User>();
        for (User user : users) {
            if (condition.test(user)) {
                newUsers.add(user);
            }
        }
        return newUsers;
    }

    public static class JudgeIdGreaterThan3 implements Judge {
        @Override
        public boolean test(User user) {
            return user.id() > 3;
        }
    }

    public static class JudgeIsWang implements Judge {
        @Override
        public boolean test(User user) {
            return user.name().startsWith("王");
        }
    }

    public static class JudgeIsRich implements Judge {
        @Override
        public boolean test(User user) {
            return user.money() > 10000;
        }
    }

    public interface Judge {
        boolean test(User user);
    }
}

当然，我们也可以使用匿名内部类来实现同样的功能。

使用 Java 8 提供的`Predicate`接口

事实上，从 Java 8 开始，JDK 提供了一个名为Predicate的接口，其作用与上方自己写的Judge接口类似。同时，因为它是函数式接口，我们可以很轻松地使用 Lambda 表达式。

Predicate 接口

public class CollectionStream {
    public static void main(String[] args) {
        // users 定义
        for (User user : getUsers(users, user -> user.id() > 3)) {
            // 判断ID是否大于3
            System.out.println(user);
        }

        for (User user : getUsers(users, user -> user.name().startsWith("王"))) {
            // 判断是否姓王
            System.out.println(user);
        }

        for (User user : getUsers(users, user -> user.money() > 10000)) {
            // 判断是否有钱
            System.out.println(user);
        }
    }

    public static List<User> getUsers(List<User> users, Predicate<User> condition) {
        final var newUsers = new ArrayList<User>();
        for (User user : users) {
            if (condition.test(user)) {
                newUsers.add(user);
            }
        }
        return newUsers;
    }
}

总结

从最初编写一个一个独立的方法，到后面自行开发接口逐步地通用化，再到使用 Lambda 表达式，我们重复的工作被逐步逐步地简化。

事实上，在 Java 推出Predicate接口，开源世界早已对于集合操作有了简化。例如以Google Guava为代表的第三方框架，以及以Groovy、Scala、Kotlin为代表的编程语言。

Steam 核心知识

创建 Stream

使用 Stream.of() 创建

最简单的方法是使用Stream.of()来创建 Stream：

Stream<String> foo = Stream.of("Java", "Python", "Kotlin", "JavaScript");
foo.forEach(System.out::println);

以上代码创建了一个由 4 个编程语言组成的流，并使用forEach()方法将其打印出来（forEach方法的参数为Consumer<T>函数式接口，可直接使用 Lambda 表达式）

使用数组创建

使用数组创建 Stream 可以使用Arrays.stream()方法来创建。

String[] foo = new String[]{"Java", "Python", "Kotlin", "JavaScript"};
Stream<String> bar = Arrays.stream(foo);
bar.forEach(System.out::println);

使用集合框架创建

同样，Stream 也可以基于集合框架来创建，Collection接口提供了stream()的抽象方法，使得Set、List、Map等集合拥有创建 Stream 的能力。

这里以 List为例：

List<String> foo = List.of("Java", "Python", "Kotlin", "JavaScript");
Stream<String> bar = foo.stream();
bar.forEach(System.out::println);

使用`Supplier`创建

我们也可以通过Stream.generate(Supplier<? extends T> s)方法来创建 Stream。这里参数要求为Supplier，它同样是个函数式接口。

// 以下事例均使用`链式操作`
Stream.generate(() -> new Random().nextInt(100))
      .limit(10)   // 此处使用`limit`来闲置元素个数
      .forEach(System.out::println);

中间操作

中间操作是指调用方法以后，仍然返回Stream对象。Java Stream 中，允许有多个中间操作。

map

Stream.map(Function<? super T,? extends R> mapper)是将一个某个操作映射到 Stream 中每个元素上。同样，map的参数为函数式接口。

例如，如下代码实现了对于每个元素进行平方：

Stream.of(1, 2, 3, 4, 5)
      .map(i -> i * i)
      .forEach(System.out::println);   // 1, 4, 9, 16, 25

map方法也可以对于元素中的对象进行操作，例如：

List.of("Java", "Kotlin", "JavaScript")
    .stream()
    .map(String::toUpperCase)     // 将元素转为大写
    .forEach(System.out::println);

filter

Stream.filter(Predicate<? super T> predicate)可以对于 Stream 中元素进行过滤。

例如，以下代码将一组数字中所有偶数打印出来：

IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
         .filter(i -> i % 2 == 0)
         .forEach(System.out::println);

如果 Stream 中元素为对象，同样可以进行过滤。例如，如下代码实现了将年龄为 18 岁以下的未成年人过滤：

record Person(String name, int age) { } // 需要使用 Java 16 及以上版本

List<Person> peoples = List.of(
    new Person("张三", 30),
    new Person("李四", 16),
    new Person("王五", 18),
    new Person("王强", 22),
    new Person("小宋", 8)
);
peoples.stream()
       .filter(it -> it.age() >= 18)
       .forEach(System.out::println);

/*
输出：
Person[name=张三, age=30]
Person[name=王五, age=18]
Person[name=王强, age=22]
*/

parallel

通常情况下，对 Stream 的元素进行处理是单线程的，即一个一个元素进行处理。但是很多时候，我们希望可以并行处理 Stream 的元素，因为在元素数量非常大的情况，并行处理可以大大加快处理速度。

record Person(String name, int age) { } // 需要使用 Java 16 及以上版本

List<Person> peoples = List.of(
    new Person("张三", 30),
    new Person("李四", 16),
    new Person("王五", 18),
    new Person("王强", 22),
    new Person("小宋", 8)
);
peoples.stream()
       .parallel()  // 将普通 stream 转换为并行 stream
       .filter(it -> it.age() >= 18)    // 并行筛选
       .forEach(System.out::println);

sorted

Stream.sorted()可以实现对 Stream 中元素进行排序，所排序的元素必须实现Comparable。当然也可以在参数中填入自己的Comparator。

如下代码对随机数进行从小到大的排序：

IntStream.of(5, 7, 3, 2, 6, 0, 9)
         .sorted()
         .forEach(System.out::println);

// 输出：0 2 3 5 6 7 9

distinct

Stream.distinct()可以对于 Stream 中的元素进行去重：

IntStream.of(5, 8, 3, 4, 5, 3, 6, 9, 5, 3, 7)
         .distinct()
         .forEach(System.out::println);

// 输出：5 8 3 4 6 9 7

skip

Stream.skip()可以对于 Stream 中前几个元素进行跳过

IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
         .skip(3)
         .forEach(System.out::println);

// 输出：4 5 6 7 8 9

limit

Stream.limit()可以只保留前几个元素：

IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
         .limit(5)
         .forEach(System.out::println);

// 输出：1 2 3 4 5

concat

Stream.concat()用于将两个 Stream 合并：

IntStream foo = IntStream.of(1, 2, 3);
IntStream bar = IntStream.of(4, 5, 6);
IntStream.concat(foo, bar)
         .forEach(System.out::println);

// 输出：1 2 3 4 5 6

终结操作

终结操作是指调用方法后，返回非Stream的操作，包括void。Java Stream 中，只允许有一个终结操作。

终结操作主要有如下方法：

forEach：对于Stream中每个元素进行遍历，常见用途如打印元素。
count/max/min：返回元素个数/最大值/最小值。
anyMatch/allMatch/noneMatch：任意一个符合/全部符合/都不符合给定的Predicate条件返回true。
findFirst/findAny：返回流中第一个/任意一个元素。
🌟collect：几乎可以将一个Stream对象转换为任何内容，例如以下代码可以将姓王的用户筛选出来，并转换为 List 集合。
```
final var ls = users.stream()
     .filter(it -> it.name().startsWith("王"))
     .collect(Collectors.toList());
```
因为collect方法较为复杂，有兴趣可以自行阅读 JDK 文档。

IDEA 流调试器

IDEA 中内置了一个名为Java Stream Debugger插件（如果没有请确保自己为最新版的 IDEA，或者尝试前往 IDEA 插件市场安装），该插件可以通过可视化的方式直观地看到 Stream 的处理过程。

使用方式：

在 Stream 流中打上断点；
启动 Debug 模式；
断点暂停后，点击 Debug 面板上的Trace Current Stream Chain按钮（如图所示）
`Trace Current Stream Chain` Button

该插件可以分步地将 Stream 操作以可视化的形式呈现出来（当然也可以通过下方的Flat Mode按钮在同一个窗口中看到所有操作）

Split Mode

Flat Mode

演示 1 - filter

public class CollectionStream {
    public record User(Integer id, String name, Integer money) { }

    public static void main(String[] args) {
        final var users = Arrays.asList(
                new User(1, "张三", 200),
                new User(2, "李四", 200),
                new User(3, "王五", 10000),
                new User(4, "赵六", 20000),
                new User(5, "王强", 80000)
        );
        users.stream()
                .filter(it -> it.money() > 10000)
                .collect(Collectors.toList());
    }
}

16373731272913.jpg

演示 2 - distinct

public class CollectionStream {
    public static void main(String[] args) {
        final var list = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2);
        list.stream()
                .distinct()
                .forEach(System.out::println);
    }
}

16373734336456.jpg

演示 3 - sorted

public class CollectionStream {
    public static void main(String[] args) {
        final var list = Arrays.asList(6, 4, 3, 5, 6, 7, 8, 2);
        list.stream()
                .sorted()
                .forEach(System.out::println);
    }
}

16373736982517.jpg

演示 4 - map

public class CollectionStream {
    public record User(Integer id, String name, Integer money) { }

    public static void main(String[] args) {
        final var users = Arrays.asList(
                new User(1, "张三", 200),
                new User(2, "李四", 200),
                new User(3, "王五", 10000),
                new User(4, "赵六", 20000),
                new User(5, "王强", 80000)
        );
        users.stream()
                .filter(it -> it.name().startsWith("王"))
                .map(User::name)
                .forEach(System.out::println);
    }
}

16373757675756.jpg

Java 8 Stream 知识分享

综述

Java Collection 体系数据处理的演进

通过不同方法来过滤不同数据

使用接口来代替重复操作

使用 Java 8 提供的`Predicate`接口

总结

Steam 核心知识

创建 Stream

使用 Stream.of() 创建

使用数组创建

使用集合框架创建

使用`Supplier`创建

中间操作

map

filter

parallel

sorted

distinct

skip

limit

concat

终结操作

IDEA 流调试器

演示 1 - filter

演示 2 - distinct

演示 3 - sorted

演示 4 - map

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

南邮通达科协技术分享

Java 8 Stream 知识分享

综述

Java Collection 体系数据处理的演进

通过不同方法来过滤不同数据

使用接口来代替重复操作

使用 Java 8 提供的Predicate接口

总结

Steam 核心知识

创建 Stream

使用 Stream.of() 创建

使用数组创建

使用集合框架创建

使用Supplier创建

中间操作

map

filter

parallel

sorted

distinct

skip

limit

concat

终结操作

IDEA 流调试器

演示 1 - filter

演示 2 - distinct

演示 3 - sorted

演示 4 - map

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

南邮通达科协技术分享

使用 Java 8 提供的`Predicate`接口

使用`Supplier`创建