Java8实战之Stream

前言

在前面一个小节中，我们已经学习了行为参数化以及Lambda表达式，通过Lambda表达式，可以使得代码更加简洁，尤其是当一个方法只需要使用一次的时候，然而，如果Java8中只有Lambda表达式的话，那还是不足以让人感到兴奋的，个人感觉，Java8中最有意思，也是最方便的功能，莫过于

Stream

了

Stream初窥

Stream

可以翻译为流，实际上其操作也是，流操作是Java8中引入的新功能，提供了更加强大的数据迭代处理方式，通过流式写法，提供了简洁的语法，主要注意的是

Stream

需要配合Lambda表达式来使用，这更加体现了行为参数化的思想，Java8通过将既定的操作封装好，同时，将对应的具体行为留给用户，极大地提高了操作的效率。

Stream

的出现，可以说是用于替代传统的容器操作的，在传统的容器操作中，当需要对容器中的某些元素进行操作的时候，我们需要迭代容器，然后筛选出合适的对象，然后再将其存放到另外的容器中，从上面的描述中，可以看到，其中的很大一部分操作：迭代容器，筛选对象，重新存放基本都是固定的，而每次都进行手动操作，显然是比较繁琐的，

Stream

则提供了更加便捷的操作，只需要通过对应的操作模式，然后给出对应的条件，即可实现对既定元素的操作。

为了下面的操作方便，我们先构造需要的元素

// User对象
class User {
    private Integer id;
    private String name;
    private Integer age;
    // 省略set，get，toString方法
}

// 构造数据
public static List<User> generateUserData() {
    Random random = new Random();
    List<User> users = new ArrayList<>();
    for (int i = ; i < ; i++) {
        users.add(new User(i, "user" + i, random.nextInt()));
    }
    return users;
}

假设现在有一个场景，我们需要从上面的列表中选取年龄大于20岁的对象，在传统的容器操作中，一般我们会这样操作

public List<User> getUserOlderThan20() {
    List<User> users = generateUserData();
    List<User> result = new ArrayList<>();
    for (User user : users) {
        if (user.getAge() >  ) {
            result.add(user);
        }
    }
    return result;
}

而在Java8中，我们可以用更加简洁的方式来实现上面的操作

public List<User> getUserOlderThan20() {
    List<User> users = generateUserData();
    List<User> result = users.stream()
            .filter(user -> user.getAge() > )
            .collect(Collectors.toList());
    return result;
}

或者上面的案例看上去并没有那么有优势，那么我们来看下下面的案例，根据年龄对用户进行分组，年龄在1-30为年轻人，31-60为中年人，60以上为老年人(例子例子，没有实际价值)

传统的操作，我们需要如下操作

public void groupUser() {
    List<User> users = generateUserData();
    Map<String, List<User>> userGroup = new HashMap<>();
    for (User user : users) {
        if (user.getAge() >  && user.getAge() <= ) {
            List<User> young = userGroup.get("young");
            if (young == null) {
                young = new ArrayList<>();
                userGroup.put("young", young);
            }
            userGroup.get("young").add(user);
        }else if (user.getAge() <= ) {
            List<User> middle = userGroup.get("middle");
            if (middle == null) {
                middle = new ArrayList<>();
                userGroup.put("middle", middle);
            }
            userGroup.get("middle").add(user);
        }else {
            List<User> old = userGroup.get("old");
            if (old == null) {
                old = new ArrayList<>();
                userGroup.put("old", old);
            }
            userGroup.get("old").add(user);
        }
    }
    System.out.println(userGroup);
}

可以看到，上面的操作还是挺繁琐的，而且比较容易出错，而在Java8中，我们则可以采用如下操作

public void testStream() {
    List<User> users = generateUserData();
    Map<String, List<User>> result = users.stream()
            .collect(Collectors.groupingBy(
                            user -> {
                                if (user.getAge() >  && user.getAge() <= ) {
                                    return "young";
                                } else if (user.getAge() <= ) {
                                    return "middle";
                                } else {
                                    return "old";
                                }}
                            ));
    System.out.println(result);
}

可以看到，代码量以及自描述性的对比还是挺明显的，

Stream

配合

Lambda

表达式，可以使得之前比较繁琐的容器操作，变得非常简单，而且，代码本身的自解释性也更强

Stream操作

在前面我们已经见识到了

Stream

本身的特点–流式操作以及方便性，接下来我们来详细学习

Stream

的用法。

Stream

的操作可以分为两种，一种是中间操作，例如前面的

filter()

操作，一种是结束操作，例如前面的

collect()

操作，每一个中间操作，都返回一个

Stream

，经过本次处理之后的

Stream

，结束操作则产生终结，其结果要么是数字，要么是字符串，要么是集合等等，总之就不再是

Stream

，也就是说，一个

Stream

可以有多个中间操作，但只能有一个结束操作

中间操作

比较常用的几种中间操作列举如下，更多的内容参考API即可

filter() ，过滤操作，入参为 Predicate<? super T> predicate
limit() ，限制操作，入参为 long maxSize
skip() ,跳过操作，入参为 long n
distinct() ，去重操作，没有入参，底层使用的是 Set 进行去重
sorted() ，排序操作，可以传入自定义的比较器 Comparator<? super T> comparator
peek() ，检查操作，用于调试操作，入参 Consumer<? super T> action
map() ，将Stream中的元素映射为其他元素，入参 Function<? super T, ? extends R> mapper
- mapToDouble() ，将Stream转为 DoubleStream ，避免装箱机制所带来的开销
- mapToLong() ,将Stream转为 LongStream ，避免装箱机制所带来的开销
- mapToInt() ，将Stream转为 IntStream ，避免装箱机制所带来的开销
flatMap() ，将多个Stream转为一个，注意与 map() 的区别，入参 Function<? super T, ? extends Stream<? extends R>> mapper

结束操作

比较常用的几个结束操作列举如下，更多的内容参考API即可

count() ，统计元素个数
forEach() ，对每个元素执行操作，入参 Consumer<? super T> action
findFirst() ，获取第一个元素
findAny() ，获取任意一个元素
anyMatch() ，检查元素是否至少有一个匹配，入参 Predicate<? super T> predicate
allMatch() ，检查所有元素是否都匹配，入参 Predicate<? super T> predicate
collect() ，将所有内容收集起来，入参 Collector<? super T, A, R> collector ，JDK中提供了众多的 Collector 的实现，所以，基本上不用自己实现
- groupingBy() ，将内容进行分组，有三个不同的版本
  - groupingBy(Function<? super T, ? extends K> classifier) ，仅能进行一次分组
  - groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) ，注意第二个参数可以是另一个 Collector ，也就是说，可以通过多次的复合，达到多次分组，或者分组后再进行其他的操作
  - groupingBy(Function<? super T, ? extends K> classifier,Supplier<M> mapFactory, Collector<? super T, A, D> downstream) ，自己提供一个容器，而不是使用默认的容器
- counting() ，等价于前面的 Stream.count()
- partitioningBy() 精简版的 groupingBy() ，仅能支持 true 、 false 两种分组
- joining() ，字符串连接，需要注意，如果Stream的内容本身不是字符串流，则需要先 map() 操作一下，将其转为字符串流，可以指定分隔符，前缀，后缀
- toList() ，将结果合并为List
- toSet() ，将结果合并为Set
- toMap() ，将结果转为Map
- toConcurrentMap() ，将结果转为并发Map
reduce() ，根据条件合并结果，可以说，上面的所有结束操作，基本上都可以通过 reduce() 来实现， reduce 有三个不同形式的参数，当JDK所提供的合并操作不满足需求时，可以通过 reduce 来实现自定义的合并操作
- T reduce(T identity, BinaryOperator<T> accumulator)
- Optional<T> reduce(BinaryOperator<T> accumulator)
- <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner)

Stream操作实例

为了更好地理解上面的内容，我们通过几个小例子来实际操作一下

// 打印出年龄在30岁以上的所有用户
    users.stream()
        .filter(user -> user.getAge() > )
        .forEach(System.out::println);
        // 如果换成 .count()，则是统计用户的个数

    // 分组并且统计各个分组的人数
    Map<String, Long> collect = users.stream()
                .collect(groupingBy(user -> {
                    if (user.getAge() <= ) {
                        return "young";
                    } else if (user.getAge() <= ) {
                        return "middle";
                    } else {
                        return "old";
                    }
                }, counting()));

    // 分组并且去重
    Map<String, Set<User>> collect = users.stream()
                .collect(groupingBy(user -> {
                    if (user.getAge() <= ) {
                        return "young";
                    } else if (user.getAge() <= ) {
                        return "middle";
                    } else {
                        return "old";
                    }
                }, toSet()));

关于Stream的介绍，大致就到这里了，为了更好地掌握Stream，需要在实际使用中多加练习，多加研究才是

总结

本小节主要学习了Stream的内容，通过对比Stream与传统的Collection操作，可以看出，通过Stream来操作容器，代码将变得更加简洁，而且，其可阅读行也更强，出错的概率也会更低，毕竟不用再自己关心迭代的过程，最后，通过几个简单的小例子，展示了Stream中两种不同的操作，中间操作以及结束操作，当然，关于Stream的更多内容，还是需要在实际使用中不断发现，不断研究，加油。

【Java8】Java8实战之StreamJava8实战之Stream

Java8实战之Stream

前言

Stream初窥

Stream操作

总结

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method