Java8 stream 流的用法

最新推荐文章于 2024-05-05 20:34:21 发布
最新推荐文章于 2024-05-05 20:34:21 发布
阅读量858 收藏 2
点赞数 1
文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42405132/article/details/129178504
版权

1、循环：forEach

2、统计个数：count 获取数量

3、过滤：filter 得到名字长度为3个字的人

4、取用前几个：limit 获取前3个数据stream.limit(3).forEach(System.out::println);

5、跳过前几个：skip 跳过前两个数据 stream.skip(3).forEach(System.out::println);

6、映射：map map是将值转换到新的流 Stream<Integer> s = stream.map(Integer::parseInt);

7、排序：sorted

8、去重：distinct stream.distinct().forEach(System.out::println);

9、条件匹配：allMatch、anyMatch、noneMatch System.out.println(stream.allMatch(s -> s.length() > 2));

10、查找第一个元素：stream.findFirst().get()

11、获取最大最小值：max、min Optional<Integer> max = Stream.of(5, 3, 6, 1).max((o1, o2) -> o1 - o2);

12、加减乘除：reduce reduce为终端操作，可以对中间操作筛选出来的流数据作出一系列的加减乘除等操作

13、组合：concat stream连接 Stream<String> newStream = Stream.concat(streamA, streamB);

14、并行Stream流创建及使用：

15、parallelStream线程安全问题

16、分组* .collect(Collectors.groupingBy(Student::getScore))

.collect(Collectors.toMap(s -> s.getName(), s -> s)) 不能有重复的K值

17、集合的拷贝

public class JavaStream流_filter_map_collect {
    /**
     * * 1、循环：forEach
       * 2、统计个数：count   获取数量
     * * 3、过滤：filter  得到名字长度为3个字的人
       * 4、取用前几个：limit   获取前3个数据stream.limit(3).forEach(System.out::println);
       * 5、跳过前几个：skip    跳过前两个数据 stream.skip(3).forEach(System.out::println);
     * * 6、映射：map  map是将值转换到新的流   Stream<Integer> s = stream.map(Integer::parseInt);
     * * 7、排序：sorted
       * 8、去重：distinct   stream.distinct().forEach(System.out::println);
       *
       * 9、条件匹配：allMatch、anyMatch、noneMatch      System.out.println(stream.allMatch(s -> s.length() > 2));
     * * 10、查找第一个元素：stream.findFirst().get()
       * 11、获取最大最小值：max、min     Optional<Integer> max = Stream.of(5, 3, 6, 1).max((o1, o2) -> o1 - o2);
       *
     * * 12、加减乘除：reduce  reduce为终端操作，可以对中间操作筛选出来的流数据作出一系列的加减乘除等操作
       * 13、组合：concat  stream连接 Stream<String> newStream = Stream.concat(streamA, streamB);
       * 14、并行Stream流创建及使用：
       * 15、parallelStream线程安全问题
     * * 16、分组* .collect(Collectors.groupingBy(Student::getScore))
     * * .collect(Collectors.toMap(s -> s.getName(), s -> s))  不能有重复的K值
       * 17、集合的拷贝
       *
     * * collect将stream流转化为给到集合 list  set map
     * *
     */
    Stream<String> stream = Stream.of(null,"1111", "222", "333", "44", "55", "55", null);

    /**
     * 1、循环
     */
    @Test
    public void testForeach() {
        stream.forEach(System.out::println);
    }

    /**
     * 2、获取数量
     */
    @Test
    public void testCount() {
        System.out.println(stream.count());
    }

    /**
     * 3、得到名字长度为3个字的人(过滤)
     */
    @Test
    public void testFilter() {
        stream.filter(s -> s.length() == 3).forEach(System.out::println);
    }

    /**
     * 4、获取前3个数据
     */
    @Test
    public void testLimit() {
        stream.limit(3).forEach(System.out::println);
    }

    /**
     * 5、跳过前两个数据
     */
    @Test
    public void testSkip() {
        stream.skip(3).forEach(System.out::println);
    }

    /**
     * 6、映射
     */
    @Test
    public void testMap() {
        Stream<Integer> s = stream.map(Integer::parseInt);
        s.forEach(System.out::println);
    }

    /**
     * 7、排序  要先过滤掉null ,不然会报空指针
     */
    @Test
    public void testSorted() {
        Stream<Integer> s = stream.filter(Objects::nonNull).map(Integer::parseInt);
        s.sorted((i1, i2) -> i2 - i1).forEach(System.out::println);
    }

    /**
     * 8、去重
     */
    @Test
    public void testDistinct() {
        stream.distinct().forEach(System.out::println);
    }

    /**
     * 9、条件匹配 有空指针异常 需要过滤掉
     */
    @Test
    public void testMatch() {
        System.out.println(stream.filter(Objects::nonNull).allMatch(s -> s.length() > 2));
        System.out.println(stream.anyMatch(s -> s.length() > 2));
        System.out.println(stream.noneMatch(s -> s.length() > 2));
    }

    /**
     * 10、查找第一个元素   有空指针异常 需要过滤掉
     */
    @Test
    public void testFind() {
        System.out.println(stream.findFirst().get());
    }

    /**
     * 11、获取最大最小值    有空指针异常 需要过滤掉
     */
    @Test
    public void testMax_Min() {
        // 获取最大值
        // 1, 3, 5, 6
        Optional<Integer> max = Stream.of(5, 3, 6, 1).max((o1, o2) -> o1 - o2);
        System.out.println("最大值: " + max.get());

        // 获取最小值
        // 1, 3, 5, 6
        Optional<Integer> min = Stream.of(5, 3,null, 6, 1).filter(Objects::nonNull).min((o1, o2) -> o1 - o2);
        System.out.println("最小值: " + min.get());

        // 获取最小值
        // 1, 3, 5, 6
        Optional<Integer> min1 = Stream.of(5, 3, 6, 1).filter(Objects::nonNull).min((o1, o2) -> o1 - o2);
        System.out.println("最小值: " + min1.get());
    }

    /**
     *12、 加减乘除：reduce  reduce为终端操作，可以对中间操作筛选出来的流数据作出一系列的加减乘除等操作
     */
    @Test
    public void testReduce() {
        // T reduce(T identity, BinaryOperator<T> accumulator);
        // T identity: 默认值
        // BinaryOperator<T> accumulator: 对数据进行处理的方式
        // reduce如何执行?
        // 第一次, 将默认值赋值给x, 取出集合第一元素赋值给y
        // 第二次, 将上一次返回的结果赋值x, 取出集合第二元素赋值给y
        // 第三次, 将上一次返回的结果赋值x, 取出集合第三元素赋值给y
        // 第四次, 将上一次返回的结果赋值x, 取出集合第四元素赋值给y
        int reduce = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
            System.out.println("x = " + x + ", y = " + y);
            return x + y;
        });
        System.out.println("reduce = " + reduce); // 21

        // 获取最大值
        Integer max = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
            return x > y ? x : y;
        });
        System.out.println("max = " + max);
    }

            public void testMapReduce() {
                // 求出所有年龄的总和
                // 1.得到所有的年龄
                // 2.让年龄相加
                Integer totalAge = Stream.of(
                        new Person("刘德华", 58),
                        new Person("张学友", 56),
                        new Person("郭富城", 54),
                        new Person("黎明", 52))
                        .map((p) -> p.getAge()).reduce(0, Integer::sum);

                System.out.println("totalAge = " + totalAge);


                // 找出最大年龄
                // 1.得到所有的年龄
                // 2.获取最大的年龄
                Integer maxAge = Stream.of(
                        new Person("刘德华", 58),
                        new Person("张学友", 56),
                        new Person("郭富城", 54),
                        new Person("黎明", 52))
                        .map(p -> p.getAge())
                        .reduce(0, Math::max);
                System.out.println("maxAge = " + maxAge);

                // 统计 a 出现的次数
                //                          1    0     0    1    0    1
                Integer count = Stream.of("a", "c", "b", "a", "b", "a")
                        .map(s -> {
                            if (s == "a") {
                                return 1;
                            } else {
                                return 0;
                            }
                        })
                        .reduce(0, Integer::sum);
                System.out.println("count = " + count);

//实际开发中 ：如果列表是中没有数据list.size()==0的时候会报错，所以需要将代码修改成如下：
               // BigDecimal sum=list.stream()
                 //       .map(User::getNum1)  //返回num1的列表
                   //     .reduce(BigDecimal.ZERO,BigDecimal::add);  //列表字段求和,默认是从0开始相加
//或者这种 需求需要返回的值为null,那么需要这样
    //currentMonthFeeList.stream().map(HotelDayElectricFeeEntity::getFee).reduce(BigDecimal::add).orElse(null);
            }

            public void testNumericStream() {
                // Integer占用的内存比int多,在Stream流操作中会自动装箱和拆箱
                Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
                // 把大于3的打印出来
                // stream.filter(n -> n > 3).forEach(System.out::println);

                // IntStream mapToInt(ToIntFunction<? super T> mapper);
                // IntStream: 内部操作的是int类型的数据,就可以节省内存,减少自动装箱和拆箱

                IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt(Integer::intValue);
                intStream.filter(n -> n > 3).forEach(System.out::println);
            }

    /**
     * 13、stream连接
     */
    @Test
    public void testContact() {
        Stream<String> streamA = Stream.of("张三");
        Stream<String> streamB = Stream.of("李四");

        // 合并成一个流
        Stream<String> newStream = Stream.concat(streamA, streamB);
        // 注意:合并流之后,不能操作之前的流啦.
        // streamA.forEach(System.out::println);

        newStream.forEach(System.out::println);
    }


    /**
     * 16、集合排序，分组
     * .collect(Collectors.groupingBy(Student::getScore))
     * .collect(Collectors.toMap(s -> s.getName(), s -> s))
     *
     * @author ljyang
     * @date 2022-9-20 15:17
     */
    @Test
    public void entitySort() {
        //Student 的 list 集合
        List<Student> studentsList = new Student().getValue();
        //studentsList=new ArrayList<>();
        System.out.println("原始数据：");
        studentsList.forEach(s ->
                System.out.println(s.getName() + " " + s.getScore() + " " + s.getHeight() + " " + s.getCollege() + "" + s.getAddress()));
        //取出用户集合中id是007并且用用户id生成一个新的集合
        List<String> ls1 = studentsList.stream().map(Student::getName).collect(Collectors.toList());
        List<String> ls2 = studentsList.stream().filter(Objects::nonNull).map(Student::getName).collect(Collectors.toList());
        List<String> ls = studentsList.stream().filter(e -> "80".equals(e.getScore())).map(Student::getName).collect(Collectors.toList());
        //分组
        Map<Integer, List<Student>> groupingByMap = studentsList.stream().collect(Collectors.groupingBy(Student::getScore));


        //抽取对象集合中的某个元素组成集合
        List<Integer> workerIds = studentsList.stream().map(Student::getScore).collect(Collectors.toList());

        //抽取对象集合中的某两个元素组成键值对存入Map
        // case0:
        Map<String, Student> workerMap = new HashMap<>();
        studentsList.forEach(worker -> workerMap.put(worker.getName(), worker));
        // case1:
        Map<String, Student> toMap = studentsList.stream().collect(Collectors.toMap(s -> s.getName(), s -> s));

        //按照集合对象的属性分组
        Map<String, List<Student>> collect = studentsList.stream().collect(Collectors.groupingBy(a -> a.getAddress()));
        //遍历Map
        collect.forEach((k, v) -> System.out.println(k + ":" + v));
    }

   /**
    *测试方法调用 之后集合是否跟着变化
    *
    */
    @Test
    public void test调用() {
        List<User> list = new ArrayList<>();
        list.add(new User(15L, "小白", 27, "1QQ",SexEnum.MALE));
        list.add(new User(16L, "红16", 26, "2QQ",SexEnum.MALE));
        list.add(new User(17L, "红17", 27, "2QQ",SexEnum.MALE));
        list.add(new User(18L, "红18", 28, "2QQ",SexEnum.MALE));
        list.add(new User(19L, "红19", 29, "2QQ",SexEnum.MALE));
        System.err.println("对象List = " + JSONObject.toJSONString(list));
//        List<User> userStream = list.stream().filter(apiId -> {
//            // api不存在或未启用
//            if (apiId.getAge() == 27) {
//                return false;
//            } else {
//                return true;
//            }
//        }).collect(Collectors.toList());
        test306(list);

        list.forEach(System.out::println);
    }
    public void test306(List<User> list) {
        list.stream().filter(apiId -> {
            // api不存在或未启用
            if (apiId.getAge()==27) {
                return false;
            }else{
                return true;
            }
        });
    }
    /**
     * 17、集合的拷贝
     */
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(15L, "小白", 23, "1QQ",SexEnum.MALE));
        list.add(new User(16L, "红16", 26, "2QQ",SexEnum.MALE));
        list.add(new User(17L, "红17", 27, "2QQ",SexEnum.MALE));
        list.add(new User(18L, "红18", 28, "2QQ",SexEnum.MALE));
        list.add(new User(19L, "红19", 29, "2QQ",SexEnum.MALE));
        System.err.println("对象List = " + JSONObject.toJSONString(list));
        List<Student> newList = list.stream().map(e -> {
            Student t = new Student();
            BeanUtils.copyProperties(e, t);
            return t;
        }).collect(Collectors.toList());
        System.err.println("拷贝出来的List = " + JSONObject.toJSONString(newList));
        list.get(0).setId(44L);
        System.err.println("修改list集合对象信息之后  = " + JSONObject.toJSONString(list));
        System.err.println("拷贝出来的List = " + JSONObject.toJSONString(newList));


        //复制到新集合中（map迭代出来）,改变旧的集合值，新的集合值也会跟着一一起变化，如果不想变化需要使用BeanUtils.clonebean(Object object)
        List<User> newresult = CollectionHelper.newArrayList(list);

    }
}

Max、Liu
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java8 Stream流使用
换了马甲的小强的博客
02-15 274
一、简述 Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API借助同样新出现的（Lambda表达式、方法引用、接口默认方法等），极大的提高编程效率和程序可读性，同时它提供串行和并行两种模式进行...
Java8 Stream 流
IMBA_09的博客
11-22 361
Stream 流 看之前：需要一些Lambda语法知识，可以查看参考资料中的文章：万字详解，JDK1.8的Lambda、Stream和日期的使用详解。 正文 Java8 API Stream 允许你以声明性方式处理数据集合或数组(通过查询语句来表达。 Stream 的特点： Stream 自己不会存储数据 Stream 不会改变源对象，他们会返回一个持有结果的新对象 Stream 操作是延迟执行的，意味着他们只会在需要结果的时候才会执行。 Stream 只能消费一次，消费完毕之后就会关闭。 Stream
java stream reduce操作加减乘除
fengchengwu2012的博客
01-20 671
java stream reduce
JavaSE进阶笔记-集合04(可变参数,Stream流)
SUIT THUG!的博客
07-17 251
1.可变参数 1.1可变参数【应用】 可变参数介绍 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了 方法的参数类型已经确定,个数不确定,我们可以使用可变参数 可变参数定义格式 修饰符 返回值类型 方法名(数据类型… 变量名) { } 可变参数的注意事项 这里的变量其实是一个数组 如果一个方法有多个参数，包含可变参数，可变参数要放在最后 可变参数的基本使用 public class ArgsDemo01 { public static void
2024年Java最新Java~stream处理中map与flatMap的比较和使用案例，我被面试官绝地反杀了
最新发布
2401_84103616的博客
05-05 739
分享一些系统的面试题，大家可以拿去刷一刷，准备面试涨薪。
stream流对集合的数进行相加
qq_50990884的博客
03-01 789
stream流对集合的数进行相加。
Java Stream流之求和
少年一贯快马扬帆，道阻且长不转弯； 要盛大，要绚烂，要哗然； 要用理想的泰坦尼克，去撞现实的冰川； 要当烧赤壁的风，而非借鉴草船； 要为了一片海，就肯翻万山。
04-14 2万+
Java Stream流之求和 流方式实现 基本数据类型 和 包装类型 的一位数组求和 package top.yangbocsu; import java.util.Arrays; /** * @author yangbocsu * @date 2022年4月14日 * @version 1.0 * @description: 流方式实现 基本数据类型 和 包装类型 的一位数组求和 */ public class Test { public static void main(St
Java如何借助Stream流进行求和呢？
热门推荐
qq_25073223的博客
07-24 3万+
stream对list进行求和的示例分享
Java stream().reduce实现数组合并操作（数值累加、数值累减、数值求最大最小值、字符串连接）
旭东怪的博客
02-21 7568
1 数值累加 int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; //lambda表达式实现 int sum = Arrays.stream(numbers).reduce(0, (current, number) -> current + number); // 55 //方法引用实现 int sum2 = Arrays.stream(numbers).reduce(0, Integer::sum); // 55 注：更多类型的数值
Java8新特性Stream流实例详解
08-29
Java8新特性Stream流实例详解 Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。...
Java8 Stream flatmap中间操作用法解析
08-18
Java8 Stream flatmap中间操作用法解析 Java8 中的 Stream API 是一个功能强大且灵活的数据处理工具，flatmap 是 Stream 中的一种中间操作，它可以对 Stream 中的单个元素进行拆分（切片），从而生成一个新的 ...
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作...Java Stream 流实现合并操作是一个常见的操作，了解合并 Stream 流的方法和原理对于 Java 开发者来说是非常重要的。在实际开发中，我们应该根据实际情况选择合适的方法来合并 Stream 流。
java8 Stream流逐行处理文本文件
08-18
今天，我们将探讨如何使用Java 8 Stream流逐行处理文本文件。 逐行读取文件 在 Java 8 中，我们可以使用 `Files.lines()` 方法来逐行读取文件内容。下面是一个简单的示例代码： ```java Path filePath = Paths.get...
详解java8中的Stream数据流
08-29
Java 8 中的 Stream 数据流是一种高效、简洁的数据处理方式，使用 lambda 表达式和方法引用来实现数据处理。Stream 支持多种数据处理方式，包括 filter、map、reduce 等操作，灵活性强，适合多种业务需求。
stream流运算：求和（基本数据类型，BigDecimal），多字段乘积求和，提取对象属性集合
poker_zero的博客
08-25 4546
stream流运算：求和（基本数据类型，BigDecimal），多字段乘积求和，提取对象属性集合
Stream流的求和 ，int 、double、 BigDecimal 三种类型的求和
咸鱼爸爸的博客
12-14 1万+
搞一下int 、double、 BigDecimal 三种类型的求和。 public static class User{ private int age;//年龄 private BigDecimal price;//金额 private double score;//评分 public int getAge() { return age; } public void setAg
JAVA8 Stream流
wenwen0209的博客
03-26 695
【代码】JAVA8 Stream流。
使用Stream流进行过滤，并相加计算总和。
硬核编程乐乐的博客
11-29 7899
需求 对一个集合进行条件过滤，然后计算某个字段值相加后的总数。 /** * 商家卖家交易实体 * */ @Data public class Trade { private String instId;//产品ID private String sz;//交易数量 private String side;//交易方向 buy：买 sell：卖 public Trade() { } } 代码 @Test public void tes
stream流日常开发积累
Mico_Cmx的博客
06-24 514
stream流在日常开发中积累的情景和对应用法

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值