Java8实战之Stream_13136445的技术博客_

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 = 0; i < 1000; i++) {
        users.add(new User(i, "user" + i, random.nextInt(100)));
    }
    return users;
}

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

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

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

public List<User> getUserOlderThan20() {
    List<User> users = generateUserData();
    List<User> result = users.stream()
            .filter(user -> user.getAge() > 20)
            .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() > 0 && user.getAge() <= 30) {
            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() <= 60) {
            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() > 0 && user.getAge() <= 30) {
                                    return "young";
                                } else if (user.getAge() <= 60) {
                                    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() > 30)
        .forEach(System.out::println);
        // 如果换成 .count()，则是统计用户的个数

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

Java8实战之Stream_List

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

总结

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