Java之Stream流

最新推荐文章于 2024-08-18 22:05:18 发布
最新推荐文章于 2024-08-18 22:05:18 发布
阅读量133 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37623020/article/details/130239885
版权

先看一个小案例体验一下stream流有多方便

案例：创建一个集合，把集合所有以"张"开头的元素存储到一个新集合中，再把"张"开头的集合中的长度为3的元素存储到新的集合中，最后遍历得到的集合。

传统方式：

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("张三丰");
        list1.add("张益达");
        list1.add("李逍遥");
        list1.add("张良");
        list1.add("小张");
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if (s.startsWith("张")) {
                list2.add(s);
            }
        }
        ArrayList<String> list3 = new ArrayList<>();
        for (String s : list2) {
            if (s.length() == 3) {
                list3.add(s);
            }
        }
        for (String s : list3) {
            System.out.println(s);
        }
    }
}

使用Stream流

        list1.stream().filter(s -> s.startsWith("张"))
                .filter(s -> s.length() == 3)
                .forEach(s -> System.out.println(s));

对比下来，使用Stream流写起来太简单啦！

Stream流的三类方法

获取Stream流

创建一条流水线，并把数据放到流水线上准备进行操作。

中间方法

流水线上的操作。一次操作完毕后，还可以继续进行其他操作。

终结方法

一个Stream流只能有一个终结方法。

使用场景

单列集合

使用Collection接口中的默认方法stream()

//单列集合 
ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("sss");
        list.add("vvv");
        list.stream().forEach(s -> System.out.println(s));

控制台结果

 

双列集合

通过keySet或entrySet获取Set集合再获取Stream流

        //双列集合
        HashMap<String, Integer> hm = new HashMap<>();
        hm.put("sdad", 20);
        hm.put("hgkj", 23);
        hm.put("wert", 26);
        hm.put("dsgfsg", 29);
        hm.keySet().stream().forEach(System.out::println);
        hm.entrySet().stream().forEach(System.out::println);

控制台结果

 

数组

Arrays中的静态方法stream生成流

 //数组
        int[] arr = {1,2,3,4,5};
        Arrays.stream(arr).forEach(System.out::println);

同种数据类型的多个数据

1，2，3，4，5...

"aaa" "bbb" "ccc"...

使用Stream.of(T...values)生成流

Stream.of(1,2,3,4,5).forEach(System.out::println);

中间操作方法filter

public class StreamDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张益达");
        list.add("李逍遥");
        list.add("张良");
        list.add("小张");
      //filter方法获取流中的每一个数据
        //test 方法中的s，依次表示流中的每一个数据
        //我们只要在test方法中对s进行判断就可以了
        //如果判断的结果为true，则当前的数据留下
        //如果判断的结果为false，则当前数据就不要
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张");
            }
        });

        //predicate接口中只有一个抽象方法test 所以我们可以使用lambda表达式来简化
        list.stream().filter((String s) -> s.startsWith("张"));
    }
}

其他中间操作方法

Stream <T> limit (long maxSize) : 截取指定参数个数的数据

Stream <T> skip (long n) : 跳过指定参数个数的数据

static <T> Stream<T> concat (Stream a, Stream b) : 合并a和b两个流为一个流

Stream <T> distinct () : 去除流中重复的元素。依赖hashcode和equals方法

public class StreamDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张益达");
        list.add("李逍遥");
        list.add("张良");
        list.add("张良");
        list.add("小张");
        list.add("小张");
        list.add("小张");
        
        //  Stream <T> limit (long maxSize) : 截取指定参数个数的数据
        list.stream().limit(2).forEach(s -> System.out.println(s));

        //  Stream <T> skip (long n) : 跳过指定参数个数的数据
        list.stream().skip(2).forEach(s -> System.out.println(s));

        //  static <T> Stream<T> concat (Stream a, Stream b) : 合并a和b两个流为一个流
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("萨达");
        list2.add("春辉");
        list2.add("饭馆");
        Stream<String> stream2 = list2.stream();
        Stream<String> stream1 = list.stream();
        Stream.concat(stream1, stream2).forEach(s -> System.out.println(s));
        //  Stream <T> distinct () : 去除流中重复的元素。依赖hashcode和equals方法
        list.stream().distinct().forEach(s -> System.out.println(s));

    }
}

终结操作方法

import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.stream.Stream;

public class StreamDemo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张益达");
        list.add("李逍遥");
        list.add("张良");
       list.stream().forEach(new Consumer<String>() {
           @Override
           public void accept(String s) {
               System.out.println(s);
           }
       });

        //   list.stream().forEach(System.out::println);
        //long count():返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }
}

stream流的收集操作

import java.util.ArrayList;
import java.util.function.Predicate;

/**
 * 定义一个集合，并添加一些指数1，2，3，4，5，6，7，8，9，10
 * 将集合中的奇数删除，只保留偶数
 * 遍历集合得到2，4，6，8，10
 */
public class StreamDemo3 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
             for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
//        list.stream().filter(new Predicate<Integer>() {
//            @Override
//            public boolean test(Integer integer) {
//                if(integer%2==0){
//                    return true;
//                }
//                return false;
//            }
//        });

//        list.stream().filter((Integer integer)-> {
//            if(integer%2==0){
//                return true;
//            }
//            return false;
//        }).forEach(System.out::println);

 list.stream().filter((Integer integer)-> integer % 2 == 0).forEach(System.out::println);
    }
}

遍历集合发现，集合并未发生变化。

结论：stream流中无法直接修改集合，数组等数据源中的数据

收集方法

.collect(Collectors.toList())

.collect(Collectors.toSet())

/**
 * 定义一个集合，并添加一些指数1，2，3，4，5，6，7，8，9，10
 * 将集合中的奇数删除，只保留偶数
 * 遍历集合得到2，4，6，8，10
 */
public class StreamDemo4 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        list.add(10);
        list.add(10);
        List<Integer> list1 = list.stream().filter((Integer integer) -> integer % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(list1);

        Set<Integer> set = list.stream().filter((Integer integer) -> integer % 2 == 0).collect(Collectors.toSet());
        System.out.println(set);
    }
}

.collect(Collectors.toMap())

/**
 * Stream流的收集方法
 * 创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄
 * "zhangsan,23"
 * "lisi,24"
 * "wangwu,25"
 * 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
 */
public class StreamDemo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");
        Map<String, Integer> map = list.stream().filter((String s) -> {
            String[] split = s.split(",");
            int age = Integer.parseInt(split[1]);
            return age >= 24;
        }).collect(Collectors.toMap(
                (String s) -> {
                    return s.split(",")[0];
                },
                (String s) -> {
                    return Integer.parseInt(s.split(",")[1]);
                }
        ));
        //遍历map
       for(Map.Entry<String,Integer> entry : map.entrySet()) {
           String key = entry.getKey();
           Integer value = entry.getValue();
           System.out.println((key + ":" + value));
       }
    }
}

练习

现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作

  • 男演员只要名字为3个字的前三人

  • 女演员只要姓林的，并且不要第一个

  • 把过滤后的男演员姓名和女演员姓名合并到一起

  • 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据

/**
 现在有两个ArrayList集合，
 分别存储6名男演员名称和6名女演员名称，
 要求完成如下的操作

 - 男演员只要名字为3个字的前三人
 - 女演员只要姓林的，并且不要第一个
 - 把过滤后的男演员姓名和女演员姓名合并到一起
 - 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
 **/
public class ActorTest {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        list1.add("周润发");
        list1.add("成龙");
        list1.add("刘德华");
        list1.add("吴京");
        list1.add("周星驰");
        list1.add("李连杰");

        list2.add("邱淑贞");
        list2.add("林小林");
        list2.add("林青霞");
        list2.add("柳岩");
        list2.add("宋茜");
        list2.add("王祖贤");

        //男演员只要名字为3个字的前三人
        List<String> manList = list1.stream().filter(s -> s.length()==3).limit(3).collect(Collectors.toList());
        System.out.println(manList);
        //女演员只要姓林的，并且不要第一个
        List<String> womanList = list2.stream().filter(s -> s.startsWith("林")).skip(1).collect(Collectors.toList());
        System.out.println(womanList);
        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(manList.stream(), womanList.stream());
        //把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
        stream.forEach(name->{
            Actor actor = new Actor(name);
            System.out.println(actor);
        });
    }
}

最后，祝您身体健康，再见

 

qq_37623020
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java之Stream流初识
12-22
Java中的Stream流是JDK 1.8引入的一项重要特性，它为处理集合数据提供了全新的方式，特别是结合Lambda表达式，极大地提升了代码的简洁性和可读性。Stream流并不是我们传统理解中的I/O流，而是用于处理数据的一种抽象...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
Java流式编程详解
兴趣是最好的老师，勤能补拙
05-08 1011
Java流式编程是一种基于函数式编程思想的编程方式，它通过将操作封装成数据流的形式来实现对集合、数组等数据结构的高效处理。Java 8引入了Stream API来支持流式编程，使得我们可以更加方便地实现复杂的数据处理逻辑。总之，Java流式编程提供了一种简单、高效的方式来处理集合、数组等数据结构，它的灵活性和可读性使得代码更易于理解和维护。
Java进阶- Stream流
Ther233的博客
02-21 807
Stream流 Stream流概述 Java中的Stream并不会存储元素，而是对数据进行计算操作 当使用一个流的时候，通常包括三个基本步骤： 1.获取一个数据源（source） 2.数据转换 3.执行操作获取想要的结果 每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以 像链条一样排列，如同链式操作一般 创建Stream流 Stream流的创建方式一 创建Stream方式1：通过集合创建 集合.stre
Java8 Stream 使用详解
qq_39939541的博客
07-12 1706
Java 8引入了Stream流的概念，它是对集合对象（Collection）进行操作的高级抽象。Stream流的操作分为两种：中间操作和终端操作。中间操作是指在流上进行的操作，返回的仍然是一个流，可以进行链式操作，而终端操作是指对流的最终操作，返回的是一个结果或者一个副作用。Stream流的特点如下：Stream流是对集合对象的一种封装，使得可以用函数式编程的方式对集合进行操作。Stream流的操作是延迟执行的，只有在终端操作时才会触发执行。
Java之stream流浅析
ldcaws的专栏
06-23 1675
Stream流是Java8中提供的一个重要新特性，它允许开发人员以声明方式处理集合。其中parallelStream其实就是一个并行执行的流，它通过默认的ForkJoinPool，可能提高你的多线程任务的速度。
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流详解
weixin_73869209的博客
06-05 1万+
Stream流是Java 8中的一个新特性，它提供了一种处理集合和数组的方式。Stream流可以让我们以一种更加简洁、高效、可读性更强的方式来处理数据。Stream流可以用于过滤、映射、排序、聚合等操作，它可以让我们避免使用循环和条件语句来处理数据，从而让代码更加简洁易懂。Stream流的操作可以分为中间操作和终止操作两种类型，中间操作返回的是一个新的Stream流，终止操作返回的是一个非Stream类型的结果。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
Java8 Stream 流
weixin_44061521的博客
12-24 2590
简介 Java8两大新特征，一是支持 lambda 表达式，二是 Stream API。在使用 Stream API 之前，最好有 lambda表达式的基础，如果不太清楚，可以看我的另一篇博客lambda表达式。 在编写代码的过程中，我们经常要对集合或数组数据进行操作，而有了 Stream API，我们能够非常轻松的对集合、数据进行映射、过滤、查找等操作，使得我们能够像操作数据库一样的操作集合。 Stream 本身并不存储元素，它并不改变源数据，每次操作都会形成一个新的流，并且只有执行了Stream的终止操
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
Java Stream 流的使用过程解析
08-25
Java Stream 流的使用过程解析 Java Stream 流是 Java 8 中引入的一种新的数据处理方式，旨在提供一种高效、灵活的数据处理方法。Stream 流提供了丰富的数据处理功能，可以对数据进行筛选、映射、聚合、分组等操作...
Spring Boot实现简单的Oracle数据库操作
最新发布
beautiful77moon的博客
08-18 363
使用到的技术：1. Spring Boot：用于简化Spring应用的开发。2. Dynamic DataSource：实现动态多数据源的访问和切换3. Oracle JDBC Driver：与Oracle数据库进行连接和交互。4. Mybatis-Plus：简化SQL映射和数据库访问。其中BaseMapper接口提供了对数据表进行基本操作的功能。5. Lombok：用于简化Java类的开发，自动生成常用的代码，比如getter、setter、构造函数等。
Linux配置Maven环境
Java全栈开发者
08-18 376
官网地址：https://maven.apache.org/download.cgi。获取其对应的下载链接（也可以使用下载到本地后，手动上传到服务器的方式）切到自己想要存放的路径后，使用wget下载。使用pwd查看文件路径，ll查看文件名称。这里以当前最新版本3.9.8为例。
【Spring框架】
m0_71941456的博客
08-18 992
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 950
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
java之stream流常用方法
01-12
以下是Java中Stream流的常用方法： 1. filter()方法：根据指定的条件过滤流中的元素。 ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<Integer> evenNumbers = numbers.stream() .filter(n ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值