jdk1.8 stream流式操作

已于 2024-01-04 10:34:04 修改
阅读量478 收藏 5
点赞数 9
文章标签： java
于 2024-01-03 16:17:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40794453/article/details/135364341
版权

前言

没使用stream流操作的时候，操作list集合是不是都用fori循环呢，写法不美观，写法比较麻烦，主要是懒。
用了stream之后，开发效率大大提升了，相见恨晚！！！

一、stream是什么？

Stream是Java 8中引入的一个新特性，用于处理集合对象，允许以声明式方式对集合进行各种操作。
Stream主要关注对集合对象进行各种便利、高效的聚合操作或大批量数据操作。使用Stream可以轻松地执行复杂的查找、过滤、筛选等操作，并且可以链式地组合多个操作，形成一个操作管道。

二、使用步骤

1.创建Stream

定义list（示例）：

List<User> userList = new ArrayList<>();
        User user1 = new User();
        User user2 = new User();
        User user3 = new User();
        user1.setName("小米");
        user1.setAge(12);
        user2.setName("华为");
        user2.setAge(13);
        user3.setName("苹果");
        user3.setAge(15);
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);

user对象

package test;

import lombok.Data;

/**
 * @program: ruoyi
 * @description:
 * @author: yangyang
 * @create: 2023-08-22 14:00
 **/
@Data
public class User {
    private Integer age;
    private String name;
    private Integer sex;
}

创建流：

Stream stream = userList.stream();

2.常用的操作

（1）filter：过滤

List<User> newUserList = userList.stream()
                .filter(item -> StringUtils.equals("小米",item.getName()))
                .collect(Collectors.toList());

打印： [User(age=12, name=小米, sex=null)]

（2）peek：将userList所有元素的age属性设置15

userList.stream()
                .peek(item -> {
                    item.setAge(15);
                })
                .collect(Collectors.toList());

打印： [User(age=15, name=小米, sex=null), User(age=15, name=华为, sex=null), User(age=15, name=苹果, sex=null)]

（3）map：取出元素list

List<String> nameList = userList.stream()
                .map(item -> item.getName())
                .collect(Collectors.toList());
        nameList.forEach(System.out::println);

打印： 小米华为苹果

（4）sorted：排序

List<User> newUserList = userList.stream()
                .sorted(Comparator.comparing(User::getAge).reversed())
                .collect(Collectors.toList());

打印： [User(age=15, name=苹果, sex=null), User(age=13, name=华为, sex=null), User(age=12, name=小米, sex=null)]

（5）findAny和findFirst对比
通常与filter过滤连用，条件成立
findFirst返回第一条，findAny返回任意一条（list数量少通常返回第一条）

User userAny = userList
                .stream()
                .filter(item ->
                        item.getAge() >= 12 && item.getAge() <= 20
                )
                .findAny()
                .orElse(null);
User userFirst = userList
                .stream()
                .filter(item ->
                        item.getAge() >= 12 && item.getAge() <= 20
                )
                .findFirst()
                .orElse(null);
打印： 两次都为User(age=12, name=小米, sex=null)

（6）其余的方法
①distinct
注意new的对象即便属性相同，内存地址不同不能这么用 因为distinct函数是比较的内存地址
list对象去重参考：

https://blog.youkuaiyun.com/qq_40794453/article/details/135380118?spm=1001.2014.3001.5501

//list中相同元素的内存地址是一样的
 @Test
    public void filter() {
        //list中相同元素的内存地址是一样的
        List<String> distinctList = Arrays.asList("abc", "bca", "ddf", "pij", "pij");
        Collection<String> distinct = distinctList.stream().distinct().collect(Collectors.toList());
        //distinct用来去掉重复的数据
        System.out.println(distinct);
    }

②limit

 @Test
    public void limit() {
        //list中相同元素的内存地址是一样的
        List<String> limitList = Arrays.asList("abc", "bca", "ddf", "pij", "pij");
        Collection<String> limit = limitList.stream().limit(2).collect(Collectors.toList());
        //limit返回一个给定长度的流，像上面给的参数是2就返回流中前面两个数据
        System.out.println(limit);
    }

③skip

@Test
    public void skip() {
        List<String> skipList = Arrays.asList("sex", "hhhhh", "ppt", "idea");
        Collection<String> collect = skipList.stream().skip(3).collect(Collectors.toList());
        //跳过skip参数中的前N个数据，返回后面的数据
        System.out.println(collect);
    }

④anyMatch 集合中是否有一个元素满足条件

@Test
    public void anyMatch() {
        List<String> anymatchList = Arrays.asList("sex", "hhhhh", "ppt", "idea");
        boolean any1 = anymatchList.stream().anyMatch(str -> str.contains("g"));
        //集合中是否有一个元素满足条件
        System.out.println(any1);
    }

noneMatch 集合中所有元素都不满足条件

@Test
    public void noneMatch() {
        //集合中所有元素都不满足条件
        List<String> noneMatchList = Arrays.asList("sex", "hhhhh", "ppt", "idea");
        //没有长度大于6的元素，属于所有的元素都不满足条件，即返回true
        boolean none1 = noneMatchList.stream().noneMatch(str -> str.length() > 6);
        System.out.println(none1);
    }

allMatch 集合中是否所有的元素都满足条件

@Test
    public void allMatch() {
        List<String> anymatchList = Arrays.asList("sex", "hhhhh", "ppt", "idea");
        boolean all1 = anymatchList.stream().allMatch(str -> str.length() > 3);
        //集合中是否所有的元素都满足条件
        System.out.println(all1);
    }

3.终止操作

（1）count 数量

@Test
    public void count() {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三-15", "李四-16", "王五-17", "赵六-18");
        long count = list.stream().count();
        System.out.println(count); 
    }

（2）toArray () 方法

@Test
    public void count() {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三-15", "李四-16", "王五-17", "赵六-18");
        long count = list.stream().count();
        System.out.println(count); 
    }

（3）collect(Collector collector) 方法：收集流中的数据，放到集合中（List Set Map）

@Test
    public void collect() {
//        1. 收集到 List 集合当中：
        ArrayList<String> listL = new ArrayList<>();
        Collections.addAll(listL, "张三-男-15", "李四-女-16", "王五-女-17", "赵六-男-18");
        List<String> newListL = listL.stream().collect(Collectors.toList());
        System.out.println(newListL);
//        2. 收集到 Set 集合当中：
        ArrayList<String> listS = new ArrayList<>();
        Collections.addAll(listS, "张三-男-15", "李四-女-16", "王五-女-17", "赵六-男-18");
        java.util.Set<String> newListS = listS.stream().collect(Collectors.toSet());
        System.out.println(newListS);
        //        3. 收集到 Map 集合当中：
        ArrayList<String> listM = new ArrayList<>();
        Collections.addAll(listM, "张三-15", "李四-16", "王五-17", "赵六-18");
        Map<String, Integer> map = listM.stream()
                .collect(Collectors.toMap(s -> s.split("-")[0], s -> Integer.parseInt(s.split("-")[1])));
        System.out.println(map);
    }
[张三-男-15, 李四-女-16, 王五-女-17, 赵六-男-18]
[李四-女-16, 王五-女-17, 赵六-男-18, 张三-男-15]
{李四=16, 张三=15, 王五=17, 赵六=18}

总结

使用Stream的好处包括减少冗余代码、提高代码可读性和可维护性，以及更好地利用多核处理器进行并行处理。

需要注意的是，虽然Java 8引入了Stream，但并不是所有集合类都支持Stream操作。一些旧版本的Java集合类可能需要使用传统的for循环或其他方法来处理数据。

初识 JDK1.8 stream流
Liveforyourself的博客
06-06 395
初识 JDK1.8 stream流
jdk1.8 List集合Stream流式处理
Yuhei001的博客
07-20 1217
Java 8 引入了一个新的抽象层——Stream API，它允许你以声明性方式处理数据集合（包括数组、集合等）。Stream API 提供了一种高效且易于表达的方式来处理数据集合，包括过滤、排序、映射和归约等操作。这种处理方式极大地提高了代码的可读性和可维护性，同时也提升了处理大量数据的性能。Stream（流）是 Java 8 引入的一个关键抽象概念，它代表了一个来自数据源的元素队列并支持聚合操作。
JDK8新特性(八)之Stream流的map()、sorted()、distinct()、match()方法
北辰
12-08 6090
Stream流的map()、flatMap()、sorted()、distinct()、match()方法
JDK8新特性：Stream（JDK8开始最大的改变）
最新发布
m0_55470667的博客
04-07 194
已知数组arr1中有如下元素{郭靖，杨康}，arr2中有如下元素{黄蓉，穆念慈}，使用Stream将二者合并到List集合。中间方法指的是调用完成后会返回新的Stream流，可以继续使用（支持链式编程）终结方法指的是调用完成后，不会返回新Stream了，没法继续使用流了。concat将两个流合成一个流。
JDK1.8新特性——Stream流
Xzh_java的博客
07-23 1230
jdk8新特性全方面了解
jdk1.8Stream流
qq_57007223的博客
07-05 163
jdk创建stream流
Java JDK 1.8 新特性 Stream流
qq_43623492的博客
01-11 730
Stream常用方法 forEach count filter limit skip map sorted distinct match max min reduce concat Collectors.maxBy/minBy/summarizingInt Collectors.groupingBy Collectors.partitioningBy Collectors.joining 并行Stream流
Java8 JDK1.8新特性之-Stream流
weixin_42263032的博客
07-16 335
Java8 JDK1.8新特性之-Stream流
jdk1.8windows免安装版本
03-16
2、Stream API：Java 8中引入了Stream API，它允许开发人员通过一组流式操作来处理集合数据。使用Stream API可以简化代码，并且可以提高代码的可读性和可维护性。 3、接口的默认方法：Java 8允许接口中包含默认方法...
jdk1.8 201Windows解压版
04-15
在这个"jdk1.8 201Windows解压版"中，我们关注的是JDK 1.8的更新版本201，该版本适用于Windows操作系统。 1. **Lambda表达式**：这是Java 8最重要的特性之一，允许开发者以更简洁的方式处理函数式编程任务。Lambda...
jdk1.8中文百度.rar
09-01
JDK 1.8是Oracle公司发布的Java平台的一个重要版本，引入了许多重要的新特性，极大地提升了开发效率和程序性能。 在JDK 1.8中，最显著的新特性是Lambda表达式，这是对函数式编程的一种支持。Lambda表达式允许开发者...
JDK1.8之集合的流式操作
abcafdsgr123456789的博客
02-27 626
本文详细介绍了(JDK) 1.8中引入的流式集合操作，这是一种新的处理集合数据的方式，旨在提高编程效率和代码可读性。文章首先概述了流式集合操作的基本概念和优势，然后详细讲解了如何创建和使用流（Stream），包括中间操作（如过滤、映射、排序等）和终端操作（如收集、归约等）。通过示例代码和解释，文章展示了如何使用流式集合操作来简化复杂的集合处理逻辑，并展示了其相对于传统集合操作的优势。此外，文章还讨论了流式集合操作的性能特点以及在使用中需要注意的事项
Stream流（jdk1.8新特性）
weixin_42343552的博客
07-26 263
使用传统的方式遍历集合对集合进行过滤 使用Stream流的方式遍历集合，对集合中的数据进行过滤 Stream关注的做什么，而不是怎么做 public static void main(String[] args) { List<String> list=new ArrayList<>(); list.add("张三"); li...
Java1.8工作中最常用的14个Stream详细小示例，你还不会吗？
m0_53223758的博客
12-04 332
一：简介 java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。Stream的操作可以串行stream()执行或者并行parallelStream()执行。 二：Stream package java.util
Java jdk1.8 Stream流式处理
htflll的博客
03-21 637
package com.htf; import java.util.*; import java.util.stream.Stream; /** * @author htf * @description: 流式处理 */ public class Test { public static void main(String[] args) { /** * jdk1.8流处理 *获取stream的方式 *
JDK1.8新特性---＞stream流
xiao-啸
08-05 766
jdk1.8新特性stream的相关操作
jdk1.8新特性Stream流处理
杨海吉
02-09 2505
导语 Stream流处理，不是IO流的处理，而是真正的函数式编程风格引入到Java中 概念 Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值