为了账号安全,请及时绑定邮箱和手机立即绑定

【Java8】Java8实战之Stream

2018.12.03 23:24 2272浏览

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(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),自己提供一个容器,而不是使用默认的容器

    • groupingBy(),将内容进行分组,有三个不同的版本

    • counting(),等价于前面的Stream.count()

    • partitioningBy()精简版的groupingBy(),仅能支持truefalse两种分组

    • 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()));

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



作者:颜洛滨
链接:https://www.jianshu.com/p/fa53980e3ed9


点击查看更多内容
6人点赞

若觉得本文不错,就分享一下吧!

评论

相关文章推荐

正在加载中
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消