Java8 Stream API 基础操作

最新推荐文章于 2024-04-13 06:15:00 发布
最新推荐文章于 2024-04-13 06:15:00 发布
阅读量328 收藏 3
点赞数
分类专栏： Java 文章标签： stream java8 Lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44129618/article/details/126293435
版权

这里写目录标题

基础操作

map/filter

先来个最简单：

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // 我们先学中间操作

        // 1.先获取流（不用管其他乱七八糟的创建方式，记住这一个就能应付95%的场景）
        Stream<Person> stream = list.stream();
        // 2.过滤得到年纪大于18岁的（filter表示过滤【得到】符合传入条件的元素，而不是过滤【去除】）
        Stream<Person> filteredByAgeStream = stream.filter(person -> person.getAge() > 18);
        // 3.只要名字，不需要整个Person对象（为什么在这个案例中，filter只能用Lambda，map却可以用方法引用？）
        Stream<String> nameStream = filteredByAgeStream.map(Person::getName);
        // 4.现在返回值是Stream<String>，没法直接使用，帮我收集成List<String>
        List<String> nameList = nameStream.collect(Collectors.toList());
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

再来一个：

public static void main(String[] args) {
    // 直接链式操作
    List<String> nameList = list.stream()
            .filter(person -> person.getAge() > 18)
            .map(Person::getName)
            .collect(Collectors.toList());
}

sorted

试着加入sorted()玩一下。

在此之前，我们先来见见一位老朋友：Comparator。

这个接口其实早在JDK1.2就有了，但当时只有两个方法：

  1. compare()
  2. equals()

在这里插入图片描述
JDK1.8通过默认方法的形式引入了很多额外的方法，比如reversed()、Comparing()等。

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // JDK8之前：Collections工具类+匿名内部类。Collections类似于Arrays工具类，我经常用Arrays.asList(）
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getName().length()-p2.getName().length();
            }
        });
        
        // JDK8之前：List本身也实现了sort()
        list.sort(new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getName().length()-p2.getName().length();
            }
        });
        
        // JDK8之后：Lambda传参给Comparator接口，其实就是实现Comparator#compare()。注意，equals()是Object的，不妨碍
        list.sort((p1,p2)->p1.getName().length()-p2.getName().length());
        
        // JDK8之后：使用JDK1.8为Comparator接口新增的comparing()方法
        list.sort(Comparator.comparingInt(p -> p.getName().length()));
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

来玩一下Stream#sorted()，看看和List#sort()有啥区别。

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // 直接链式操作
        List<String> nameList = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println(nameList);

        // 我想按姓名长度排序
        List<String> sortedNameList = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedNameList);

        // Stream（默认自然排序）

        // 按照长度倒序（注意细节啊，str2-str1才是倒序）
        List<String> realSortedNameList = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .sorted((str1, str2) -> str2.length() - str1.length())
                .collect(Collectors.toList());
        System.out.println(realSortedNameList);

        // sorted()有重载方法，是sorted(Comparator)
        // 上面Lambda其实就是调用sorted(Comparator)，用Lambda给Comparator接口赋值
        // 但Comparator还供了一些方法，能返回Comparator实例
        List<String> optimizeNameList = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());
        System.out.println(optimizeNameList);

        // 又是一样的套路，Comparator.reverseOrder()返回的其实是一个Comparator

        // 但上面的有点投机取巧，来个正常点的，使用Comparator.comparing()
        List<String> result1 = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .sorted(Comparator.comparing(t -> t, (str1, str2) -> str2.length() - str1.length()))
                .collect(Collectors.toList());
        System.out.println(result1);

        // 我去，更麻烦了！！
        // 不急，我们先来了解上面案例中Comparator的两个参数
        // 第一个是Function映射，就是指定要排序的字段，由于经过上一步map操作，已经是name了，就不需要映射了，所以是t->t
        // 第二个是比较规则
        
        // 我们把map和sorted调换一下顺序，看起来就不那么别扭了
        List<String> result2 = list.stream()
                .filter(person -> person.getAge() > 18)
                .sorted(Comparator.comparing(Person::getName, String::compareTo).reversed())
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println(result2);

        // 为什么Comparator.comparing().reversed()可以链式调用呢？
        // 因为Comparator.comparing()返回的还是Comparator对象~
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

limit/skip

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        List<String> result = list.stream()
                .filter(person -> person.getAge() > 17)
                // peek()先不用管，它不会影响整个流程，就是打印看看filter操作后还剩什么元素
                .peek(person -> System.out.println(person.getName()))
                .skip(1)
                .limit(2)
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println(result);
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

结果
==== 过滤后的元素有3个 ====
i
am
iron

==== skip(1)+limit(2)后的元素 ====
[am, iron]

所谓的skip(N)就是跳过前面N个元素，limit(N)就是只取N个元素。

collect

collect()是最重要、最难掌握、同时也是功能最丰富的方法。

最常用的4个方法：Collectors.toList()、Collectors.toSet()、Collectors.toMap()、Collectors.joining()

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // 最常用的4个方法

        // 把结果收集为List
        List<String> toList = list.stream().map(Person::getAddress).collect(Collectors.toList());
        System.out.println(toList);
        
        // 把结果收集为Set
        Set<String> toSet = list.stream().map(Person::getAddress).collect(Collectors.toSet());
        System.out.println(toSet);
        
        // 把结果收集为Map，前面的是key，后面的是value，如果你希望value是具体的某个字段，可以改为toMap(Person::getName, person -> person.getAge())
        Map<String, Person> nameToPersonMap = list.stream().collect(Collectors.toMap(Person::getName, person -> person));
        System.out.println(nameToPersonMap);

        // 把结果收集起来，并用指定分隔符拼接
        String result = list.stream().map(Person::getAddress).collect(Collectors.joining("~"));
        System.out.println(result);
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

关于collect收集成Map的操作，有一个小坑需要注意：

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("iron", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        Map<String, Person> nameToPersonMap = list.stream().collect(Collectors.toMap(Person::getName, person -> person));
        System.out.println(nameToPersonMap);
    }

    @Getter
    @Setter
    @AllArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", address='" + address + '\'' +
                    ", salary=" + salary +
                    '}';
        }
    }
}

尝试运行上面的代码，会观察到如下异常：

Exception in thread "main" java.lang.IllegalStateException: Duplicate key Person{name='iron', age=21, address='杭州', salary=888.8}

这是因为toMap()不允许key重复，我们必须指定key冲突时的解决策略（比如，保留已存在的key）：

public static void main(String[] args) {
    Map<String, Person> nameToPersonMap = list.stream()
            .collect(Collectors.toMap(Person::getName, person -> person, (preKey, nextKey) -> preKey));
    System.out.println(nameToPersonMap);
}

如果你希望key覆盖，可以把(preKey, nextKey) -> preKey)换成(preKey, nextKey) -> nextKey)。

你可能会在同事的代码中发现另一种写法：

public static void main(String[] args) {
    Map<String, Person> nameToPersonMap = list.stream().collect(Collectors.toMap(Person::getName, Function.identity());
    System.out.println(nameToPersonMap);
}

Function.identity()其实就是v->v：

在这里插入图片描述

但它依然没有解决key冲突的问题，而且对于大部分人来说，相比person->person，Function.identity()的可读性不佳。

聚合：max/min/count

max/min

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // 匿名内部类的方式，实现Comparator，明确按什么规则比较（所谓最大，必然是在某种规则下的最值）
        Optional<Integer> maxAge = list.stream().map(Person::getAge).max(new Comparator<Integer>() {
            @Override
            public int compare(Integer age1, Integer age2) {
                return age1 - age2;
            }
        });
        System.out.println(maxAge.orElse(0));

        Optional<Integer> max = list.stream().map(Person::getAge).max(Integer::compareTo);
        System.out.println(max.orElse(0));
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

count

public static void main(String[] args) {
    long count = list.stream().filter(person -> person.getAge() > 18).count();
    System.out.println(count);
}

去重：distinct

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        long count = list.stream().map(Person::getAddress).distinct().count();
        System.out.println(count);
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

所谓“去重”，就要明确怎样才算“重复”。那么，distinct()是基于什么标准呢？

还是那两样：hashCode() 和 equals()，所以记得重写这两个方法（一般使用Lombok的话问题不大）。

distinct() 提供的去重功能比较简单，就是判断对象重复。如果希望实现更细粒度的去重，比如根据对象的某个属性去重，可以怎么做呢？可以参考：分享几种 Java8 中通过 Stream 对列表进行去重的方法

一般来说，这些用法已经覆盖实际开发90%的场景了。

SuZhan7710
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java8 Stream API
xc_oo0的博客
01-29 985
java stream Java 8 java.util.stream Stream API的中间操作有filter、map、distinct、sorted、skip、limit、peek、mapToLong、mapToInt、mapToDouble、flatMap等 Stream API的终端操作有collect、max、min、count、allMatch、anyMatch、noneMatch、findFirst、findAny、forEach、toArray、reduce等。
Java 8 Stream API
java_dazhuzhu的博客
08-09 530
Java 8 介绍 Java 8 发版于 2014 年，多年过去，目前依旧是最常用的 JDK 版本 Java 8 在增强代码可读性、简化代码方面，增加了很多功能，比如 Lambda、Stream 流操作、并行流（ParallelStream）、Optional 可空类型、新的日期时间类型等 Lambda 表达式配合 Stream 流操作为我们日常编码极大的提升了效率 Lambda 表达式 匿名类内部类虽然没有类名，但还是要给出方法定义 Lambda 表达式的初衷是进一步简化匿名类的语法
Java一个List中的部分字段赋值给另一个List（使用stream）
侯中飞的博客
09-11 1万+
Java一个List中的部分字段赋值给另一个List: 当接口中需要使用一个list中的部分值的作为最终结果，可以使用下面的方式进行简单构造，之前喜欢用迭代器，这种方式更加简洁。 List<KeyWordSearchResponse> companyNameList = qccService.findCompanyNameList(keyword); return companyNameList.stream().map(result -> new CompanyName
实用宝典：Java8 Stream实用小技巧记录
yangm666的博客
04-28 3878
最近发现这个Stream用的还是挺多的，基础语法掌握了，但是遇到实际场景的时候，又需要浪费很多时间才能写出来，所以对常用场景的写法进行总结，方便真实场景中快速应用。
Java中批量修改List集合中某个字段的两种方法
最新发布
NCGZS
04-13 879
Java中批量修改List集合中某个字段的两种方法
Java中，常用的List的五种声明并赋值操作
Letol的博客
10-24 2万+
面向Java新手，提高效率。
Stream流将List列表中的每个对象赋值给另外一个List列表中的每个对象
qq_44825854的博客
03-15 1164
当使用流操作（stream）遍历订单详情列表并将每个订单详情对象转换为购物车对象时，代码段中的Lambda表达式起着关键作用。方法将订单详情对象的属性复制到购物车对象中。通过这种方式，对订单详情列表中的每个订单详情对象进行转换，最终得到一个包含所有转换后购物车对象的列表。方法将列表转换为一个流，使得我们可以对列表中的每个元素进行处理。方法将转换后的购物车对象收集到一个列表中，并返回该列表。转换为一个购物车对象，并返回该购物车对象。在每次迭代中，新创建一个购物车对象，并使用。
java利用stream流查出符合某个条件的list，并且进行赋值
热门推荐
张伟光
03-30 4万+
List<WorkHandoverModel>workHandoverList2=workHandoverList.stream().filter(item->item.getIsDelete().equals(0)).collect(Collectors.toList());//获取list中符合没有删除的工作交接的list List<WorkHandoverMode...
Java8 Stream API 详细使用方法与操作技巧指南
08-19
Java8 Stream API 详细使用方法与操作技巧指南 Java 8 引入了 Stream API，这是一个重要的特性，允许开发者以一种声明式的方式对数据进行处理。Stream 翻译过来是“流”，它可以看做是一个可操作的数据集序列，具有...
Java 8 Stream Api 中的 map和 flatMap 操作方法
08-25
Java 8 Stream Api 中的 map 和 flatMap 操作方法 在 Java 8 中，Stream Api 提供了两个重要的中间操作：map 和 flatMap。这两种操作方法是非常有用的，可以帮助开发者简便地解决一些数据流的操作问题。 map 操作...
Java8 Stream flatmap中间操作用法解析
08-18
Java8 中的 Stream API 是一个功能强大且灵活的数据处理工具，flatmap 是 Stream 中的一种中间操作，它可以对 Stream 中的单个元素进行拆分（切片），从而生成一个新的 Stream。今天，我们将深入了解 Java8 Stream ...
基于Java8 Stream API实现数据抽取收集
08-24
基于Java8 Stream API实现数据抽取收集 Java8 Stream API是Java8中一个功能强大的API，提供了许多实用的方法来处理数据。该API基于函数式编程的思想，提供了许多抽象的数据处理方法。Stream API可以用来处理大量的...
java8-Stream API终端操作.pdf
07-12
Java 8 Stream API 终端操作 Java 8 中的 Stream API 提供了强大的数据处理功能，其中的终端操作是指将 Stream 处理结果转换为实际的数据结构。Java Stream 管道流数据处理操作可以分为三个阶段：第一阶段是将集合...
stream常用操作
C18298182575的博客
10-17 1658
List<ProductApplyDetail> detailList = null; 1，取list对象属性 List<String> applyOrderNos = detailList.stream().map(v -> v.getApplyOrderNo()).collect(Collectors.toList()); List<ProductAp...
Stream的创建以及使用
IdealSpring的博客
08-17 491
一、描述         JKD1.8新增的接口，可以实现对数组、集合等类似于spark算子的所有操作。 二、创建Stream对象 // 1.通过数组创建 String[] arr = {"a", "b", "c", "d", "e"}; Stream&lt;String&gt; streamArr = Stream.of(arr);
Java 8 中的 Streams API 详解
qq_34327621的博客
09-09 494
陈争云, 占宇剑, 司磊 发布: 2014-09-11 原创地址:https://developer.ibm.com/zh/articles/j-lo-java8streamapi/ 为什么需要 Stream Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的
Java List Stream流，去空，字段赋值，去重
weixin_44414188的博客
04-30 9942
Java List Stream流，去空，字段赋值，去重 1.实体类 /** * @description 用户 * @author ln */ @Data public class User { private String id; private String name; private String nickname; private String sex; private String age; private String type; }
java stream 实现给集合中的每一个对象字段进行赋值
susu1083018911的博客
03-27 905
java stream 实现给集合中的每一个对象字段进行赋值
Java8 Stream API讲解
07-11
Java 8 中的 Stream API 提供了许多有用的方法来处理集合数据。常见的 API 包括： - filter()：过滤元素 - map()：将元素映射成另一种元素 - limit()：限制流中元素的数量 - sorted()：按照顺序对元素进行排序 - forEach()：对流中的每个元素进行操作 - collect()：将流转换为集合或其他容器 - reduce()：对流中的元素进行归纳操作 这只是 Stream API 中的一些常用方法，还有许多其他有用的方法可供使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SuZhan7710

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值