Java Stream流

最新推荐文章于 2024-11-07 10:15:41 发布
最新推荐文章于 2024-11-07 10:15:41 发布
阅读量933 收藏 8
点赞数 15
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63635872/article/details/139296368
版权

Stream流

1、Stream例子

需求：

​ 创建一个集合，存储多个字符串元素，完成：

  1. 把所有以”张“开头的元素存储到新的集合中。
  2. 把”张“开头，且长度为3的元素存储的新的集合中。
  3. 打印最终结果。

不使用Stream：

      ArrayList<String> list = new ArrayList<String>() {{
        add("张无忌");
        add("周芷若");
        add("赵敏");
        add("张强");
        add("张三丰");
      }};
      // 1、把所有以”张“开头的元素存储到新的集合中。
      ArrayList<String> list2 = new ArrayList<String>();
      for (String s : list) {
        if (s.startsWith("张")) {
          list2.add(s);
        }
      }
      // 2、把”张“开头，且长度为3的元素存储的新的集合中。
      ArrayList<String> list3 = new ArrayList<String>();
      for (String s : list2) {
        if (s.length() == 3) {
          list3.add(s);
        }
      }
      // 3、输出结果
      list3.forEach(System.out::println);

使用Stream：

  ArrayList<String> list = new ArrayList<String>() {{
    add("张无忌");
    add("周芷若");
    add("赵敏");
    add("张强");
    add("张三丰");
  }};
  list.stream().filter(s -> s.startsWith("张"))
    			.filter(s -> s.length() == 3)
    			.forEach(System.out::println);

分析：

​ 可见，Stream流极大简化了代码，使代码十分简洁。

2、流的思想

​ 可以把流理解成流水线，每一步都对数据进行一定的操作。

上面流的例子中，就类似于工程流水线，做了如下操作：

过滤以'张'开头的元素
过滤三个字的元素
张无忌、周芷若、赵敏、张强、张三丰
张无忌、张强、张三丰
张无忌、张三丰
遍历输出

3、流的作用

​ 结合lambda表达式，简化对流、数组的操作。

4、流的使用

使用步骤：

  1. 先得到一条Stream流、并将数据放上去。
  2. 使用Stream流中的API对数据进行各种操作（过滤、转换、统计、打印等）。

其中各种API被分为：

​ **中间方法：**方法返回值还是Stream流，也就是说中间方法操作完后，还可以调用其他API。

​ **终结方法：**最后一步，调用完毕之后，不能再调用其他API了。

a、获取Stream流
获取方式方法名说明
单列集合default Stream stream()Collection中默认方法
双列集合无无法直接使用stream流，需要使用keySet、values、entrySet转为Set后再使用Set的流操作。
数组public static Stream stream(T[] array)Arrays工具类中的静态方法
一堆零散数据public static Stream of(T…values)Stream接口中的静态方法

单列集合：

  ArrayList<Integer> list = new ArrayList<>();// 创建单列集合
  Collections.addAll(list, 1, 2, 3, 4, 5);// 添加数据
  Stream<Integer> stream = list.stream();// 获取单列集合的stream流

双列集合：

	HashMap<String,Integer> map = new HashMap<String,Integer>(){
    {
      put("aaa",111);
      put("bbb",111);
      put("ccc",111);
      put("ddd",111);
    }
  };// 创建双列集合并添加数据
  Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream(); //获取键值对流
  Stream<String> keyStream = map.keySet().stream();// 获取键的流
  Stream<Integer> valueStream = map.values().stream();// 获取值的流

数组：

  int[] arr1 = {1, 2, 3, 4}; // 创建基础数据类型数组
  String[] arr2 = {"a","b","c"}; // 创建引用数据类型数组
  IntStream intStream = Arrays.stream(arr1); // 创建基础数据类型数组的流
  Stream<String> stringStream = Arrays.stream(arr2);// 创建引用类型数组的流

零散数据：

  Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5); //注意，基础数据类型自动会装箱为引用数据类型
  Stream<String> stringStream1 = Stream.of("a", "b", "c");// 引用数据类型流

Stream.of()源码：

​ 可见，源码中传入的是一个泛型的可变参数，也就是说可以传递数组。

​ 但是要注意，这里可以传递引用数据类型的数组，不可以传递基础数据类型数组。

​ 因为会将基础数据类型数组整体当作一个参数，并不自动装箱。

    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }

  // 基础数据类型数组使用Stream.of()方法构造流 
  int[] arr1 = {1, 2, 3, 4};
  Stream.of(arr1).forEach(System.out::println); //这里会直接输出arr1的地址，而不会一次输出值
	// 意味着基础数据类型会被当作一个整体，并不进行自动装箱。
b、Stream中间方法

​ 中间方法都是对流做一定操作后返回操作后的流。

​ 因为返回值还是流，所以可以继续进行流操作，因此叫做中间方法。

常见方法：

方法作用
Stream filter(Predicate<? super T> predicate)过滤，根据传入的方法返回值过滤
Stream limit(long maxSize)截取前指定参数个数的数据
Stream skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的流
Stream distinct()元素去重，依赖hasCode()和equals()方法
static Stream concat(Stream a, Stream b)合并a和b两个流为一个流，如果两个流类型不同则会转换为二者的共同父类
Stream map(Function<T,R> mapper)返回由给定函数应用于此流的元素的结果组成的流，即转换流中的元素

注意：

  1. 中间方法都是对流进行一定操作后返回新的流，原来的流就不存在了，建议使用链式编程。
    这里说的原来流不存在指的是：
    1. 将流1赋值给变量stream1。
    2. 操作stream1后将新的流赋值给变量stream2。
    3. 此时再次操作stream1就会报错：stream has already bean operated or closed
  2. 修改集合生成的流里的数据，不会影响集合或数组原来的数据。
1.filter()：过滤

​ 方法名：Stream<T> filter(Predicate<? super T> predicate)

​ Predicate：是一个函数式接口，需要实现boolean test(T t);方法。

​ 该方法的返回值为true则留下当前元素，否则过滤掉。

​ 因此，可以使用lambda去实现这个函数式接口。

2.limit()和skip():

​ 这两个方法中传递的参数和索引无关，都是多少个。

​ 比如limit(3)指的是只取前三个元素，而不是索引为3的元素前所有元素。

3.distinct()：去重

​ 底层使用HashSet存储元素，而HashSet依赖hasCode()和equals()方法进行去重。

4.concat()：合并

​ 合并两个流的时候，尽可能让两个流类型一致，不然合并后就是两个流的共同父类，这样就会使得子类特有方法无法使用。

5.map()：转换
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "张三-20", "李四-21", "王五-22", "赵六-23");
        // 需求：打印每个人的年龄
        // 分析：就是将字符串转换为了数值类型
        /**
         * 这个函数式接口有两个泛型：
         *  第一个是传入参数的泛型，在本例中为String。
         *  第二个是返回值参数的泛型，在本例中为Integer。
         * 需要实现方法apply()，其参数就是第一个泛型，返回值类型就是第二个泛型
         * 注意：泛型不能为基础数据类型
         */
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                String[] split = s.split("-");
                String result = split[1];
                return Integer.parseInt(result);
            }
            // 在map()方法后，新流的类型就已经变成了Integer
        }).forEach(System.out::println);

        // 上述代码使用lambda就可以简写为：
        list.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(System.out::println);
c、Stream终结方法

​ 终结方法的返回值不再是流，因此无法继续进行流操作。

常见方法：

方法作用
void forEach(Consumer action)遍历
long count()统计
toArray()收集流中数据，放到数组中。
collect(Collector collector)收集流中数据，放到集合中。
1.forEach()：遍历
				List<String> list = new ArrayList<>();
        Collections.addAll(list, "张三-20", "李四-21", "王五-22", "赵六-23");
        // 需求：打印每个人的年龄
        // 分析：就是将字符串转换为了数值类型
        /**
         * Consumer泛型：表示流中数据的类型。
         * 函数式接口需实现方法action()参数 s：依次表示流里的每一个数据
         */
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s.split("-")[1]);
            }
        });

        // 上述代码使用lambda就可以简写为：
        list.stream().forEach(s -> System.out.println(s.split("-")[1]));
2.count()：统计

​ 该方法主要用来统计流过滤后的数据个数，返回值为long类型的整数。

3.toArray()：收集到数组
//重载了两个同名方法
// 1.无参数:返回一个包含此流的元素的数组(Object类型)
Object[] toArray();
// 2.返回一个包含此流元素的数组，使用提供的 generator 函数来分配返回的数组
//  以及分区执行或调整大小可能需要的任何其他数组。
<A> A[] toArray(IntFunction<A[]> generator);

带参数toArray()：

				List<String> list = new ArrayList<>();
        Collections.addAll(list, "张三-20", "李四-21", "王五-22", "赵六-23");
        /**
         * 泛型：? extends Object[]：指的是继承至Object类型的数组，本例中为字符串数组
         * 函数式方法apply()参数：流中数据的个数，要跟流中个数一致
         *  返回值：具体类型的数组
         *  方法体：创建数组
         * toArray()方法作用就是：创建一个指定类型的数组。
         *  底层实现：会依次得到流里的每一个数据，并把数据放到数组中。
         */
        list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        // 使用lambda简写
        list.stream().toArray(value -> new String[value]);
4.collect():收集到集合
			/*
            collect(Collector collector)收集流中的数据，放到集合中 (List Set Map)
            注意点：
                如果我们要收集到Map集合当中，键不能重复，否则会报错
       */
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
                "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");

        //收集List集合当中
        //需求：
        //我要把所有的男性收集起来
        List<String> newList1 = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toList());

        //收集Set集合当中
        //需求：
        //我要把所有的男性收集起来
        Set<String> newList2 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toSet());
        //System.out.println(newList2);

        //收集Map集合当中
        //谁作为键,谁作为值.
        //我要把所有的男性收集起来
        //键：姓名。 值：年龄
        Map<String, Integer> map = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                /*
                 *   toMap : 参数一表示键的生成规则
                 *           参数二表示值的生成规则
                 *
                 * 参数一：
                 *       Function泛型一：表示流中每一个数据的类型
                 *               泛型二：表示Map集合中键的数据类型
                 *
                 *        方法apply形参：依次表示流里面的每一个数据
                 *               方法体：生成键的代码
                 *               返回值：已经生成的键
                 *
                 *
                 * 参数二：
                 *        Function泛型一：表示流中每一个数据的类型
                 *                泛型二：表示Map集合中值的数据类型
                 *
                 *       方法apply形参：依次表示流里面的每一个数据
                 *               方法体：生成值的代码
                 *               返回值：已经生成的值
                 *
                 * */
                .collect(Collectors.toMap(
                  			new Function<String, String>() {
                          @Override
                          public String apply(String s) {
                            //张无忌-男-15
                            return s.split("-")[0];
                          }
                        },
                        new Function<String, Integer>() {
                            @Override
                            public Integer apply(String s) {
                                return Integer.parseInt(s.split("-")[2]);
                            }
                        }));
        Map<String, Integer> map2 = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toMap(
                        s -> s.split("-")[0],
                        s -> Integer.parseInt(s.split("-")[2])));
2418728171
关注
专栏目录
Java Stream流（详解）
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
java Stream流
qq_34376868的博客
10-24 253
mport static java.util.stream.Collectors.groupingBy; public class stream { //比如说 你需要在一个列表中 筛选出所以大于15的苹果，然后按照颜色分组 //按常规的筛选写法 就是在循环里面 迭代筛选 public static void main(String[] args) { List<Apple> appleList = new ArrayList<>(); .
Java Stream流详解
唯有努力，方可自信！
06-10 3万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 8万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
探索Java Stream流：概念、应用与代码示例详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-30 5万+
Java Stream流为处理集合数据提供了强大的工具集，其声明式、延迟计算和可并行化的特性使得代码更为简洁、高效。通过熟练掌握Stream API的使用，开发者能够编写出易于理解、易于维护且高性能的Java程序。在实际项目中，应根据具体需求灵活运用Stream的各种操作，同时注意衡量并行流的收益与成本，以达到最佳的编程效果。持续实践与探索，将使您在Java编程中充分受益于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_43060759的博客
07-15 320
综述 stream流提供可以以一种声明的方式处理数据，是一个来自数据源的元素队列并支持聚合操作。 原元素是特定类型的对象，形成一个队列。stream并不会存储元素，而是按需计算。 数据源 也即是流的来源，可以是集合、数组、IO/channel等。 聚合操作，如filter, map, reduce, find, match, sorted等。 要得到一个stream通常不会手动创建，而是调用已存在的方法如： Collection.stream() Collection.parallelStream()
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
JAVA Stream 流
qq_46263740的博客
02-24 120
JAVA Stream 流 1.1 体验Stream 流 需求：按照下面的要求完成集合的创建和遍历 创建一个集合，存储多个字符串元素 把集合中所有以 ” 小 “ 开头的元素存储到一个新的集合 把 ” 小 “ 开头的集合中的长度为3的元素存储到一个新的集合 遍历上一步得到的集合 使用Stream流的方式完成过滤操作 list.stream().filter(s -> s.startsWith("小")).filter(s -> s.length() == 3).forEach(System.
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 655
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 802
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 276
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 422
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 279
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
GEMM优化（待更新）
qq_62704693的博客
11-03 754
来源参考：深入浅出GPU优化系列：GEMM优化（一） - 知乎深入浅出GPU优化系列：GEMM优化（二） - 知乎深入浅出GPU优化系列：GEMM优化（三） - 知乎。
greendao使用封装
最新发布
白高林的专栏
11-07 265
greenDAO
Java项目实战II基于Spring Boot的秒杀系统设计与实现（开发文档+数据库+源码）
2401_86524610的博客
11-03 512
在互联网电商蓬勃发展的今天，秒杀活动已成为各大电商平台吸引用户、提升销量的重要手段。然而，秒杀活动带来的瞬时高并发访问量对系统的性能和稳定性提出了严峻挑战。传统的系统架构往往难以承受如此巨大的压力，容易出现系统崩溃、数据不一致等问题。基于Spring Boot的秒杀系统，正是为了解决这些问题而设计的。该系统利用Spring Boot框架的简洁性、高效性和可扩展性，结合分布式架构、缓存技术、消息队列等先进技术，构建了一个能够应对高并发访问、保证数据一致性和系统稳定性的秒杀平台。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值