【JAVA】使用Java8 stream流对进行遍历、过滤、查询、去重、排序、分组等

最新推荐文章于 2024-09-07 16:55:06 发布
最新推荐文章于 2024-09-07 16:55:06 发布
阅读量1.3k 收藏 29
点赞数 14
分类专栏： # java新特性 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44048876/article/details/137481205
版权

Java Stream（流）是Java 8引入的一个强大的新特性，用于处理集合数据。它提供了一种更简洁、更灵活的方式来操作数据，可以大大提高代码的可读性和可维护性。本文将详细介绍Java Stream流的概念、用法和一些常见操作。

目录

初始化数据

// 模拟数据1
public List<Student> getList(){
    List<Student> studentList = new ArrayList<>(5);
    Student student1 = new Student("张三", "001", 60, 80d, 0);
    Student student2 = new Student("李四", "001", 62, 82d, 0);
    Student student3 = new Student("王五", "002", 64, 84d, 0);
    Student student4 = new Student("赵六", "002", 66, 86d, 1);
    Student student5 = new Student("齐七", "003", 68, 88d, 2);

    studentList.add(student1);
    studentList.add(student2);
    studentList.add(student3);
    studentList.add(student4);
    studentList.add(student5);
    return studentList;
}


// 模拟数据2
public List<String> getListStr(){
    List<String> list = new ArrayList<>();
    list.add("A");
    list.add("C");
    list.add("B");
    list.add("C");
    return list;
}

实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private String name;
    private String classes;
    private Integer score1;
    private Double score2;
    private Integer type;


    public Student(Integer score1, Double score2) {
        this.score1 = score1;
        this.score2 = score2;
    }
}

一、基本玩法

1.1 List转Map

item中的某个字段作为key, value为对象本身

/**
 * list转map  name作为key, value为student
 */
@Test
public void test01(){
   List<Student> studentList = getList();
    
   // list转map  name作为key, value为student
   Map<String, Student> studentMap = studentList.stream()
               .collect(Collectors.toMap(Student::getName, student -> student));

    studentMap.forEach((k, v) ->{
           System.out.println("k=" + k + ", v=" + v.toString());
       });
}

打印结果：（点击左侧小三角显示）====================================>

k=齐七, v=Student(name=齐七, classes=003, score1=68, score2=88.0, type=2)
k=李四, v=Student(name=李四, classes=001, score1=62, score2=82.0, type=0)
k=张三, v=Student(name=张三, classes=001, score1=60, score2=80.0, type=0)
k=王五, v=Student(name=王五, classes=002, score1=64, score2=84.0, type=0)
k=赵六, v=Student(name=赵六, classes=002, score1=66, score2=86.0, type=1)

1.2 取某一个字段生成新的List

@Test
public void test01(){
   List<Student> studentList = getList();
    
    // 1、取list中每个item的name字段组成新的list
    List<String> collect = studentList.stream()
               .map(Student::getName)
               .collect(Collectors.toList());
    System.out.println("collect = " + collect);
}

打印结果：（点击左侧小三角显示）====================================>

collect = [张三, 李四, 王五, 赵六, 齐七]

1.3 去重

/**
 * 去重
 */
@Test
public void test02(){
    List<String> listStr = getListStr();
    System.out.println("去重前 = " + listStr);
    listStr = listStr.stream().distinct().collect(Collectors.toList());
    System.out.println("去重后=" + listStr);
}

打印结果：（点击左侧小三角显示）====================================>

去重前 = [A, C, B, C]
去重后 = [A, C, B]

1.4 排序

@Test
public void test01(){
   List<Student> studentList = getList();
    
    // 1、取list中每个item的name字段组成新的list
    List<String> collect = studentList.stream()
               .map(Student::getName)
               .collect(Collectors.toList());
    System.out.println("collect = " + collect);
}

打印结果：（点击左侧小三角显示）====================================>

student = Student(name=齐七, classes=003, score1=68, score2=88.0, type=2)
student = Student(name=赵六, classes=002, score1=66, score2=86.0, type=1)
student = Student(name=王五, classes=002, score1=64, score2=84.0, type=0)
student = Student(name=李四, classes=001, score1=62, score2=82.0, type=0)
student = Student(name=张三, classes=001, score1=60, score2=80.0, type=0)

1.5 过滤

/**
 * 过滤 -- 根据List过滤班级（简单使用可以）
 */
@Test
public void test04(){
    // 过滤出classes=001和003的学生
    ArrayList<String> list = new ArrayList<>();
    list.add("001");
    list.add("003");
    List<Student> studentList = getList();

    List<Student> collect = studentList.stream()
            .filter(student -> student.getClasses().equals("001"))
            .collect((Collectors.toList()));

    for (Student student : collect) {
        System.out.println("student = " + student);
    }

    System.out.println("--------------- 分割线 ---------------");

    List<Student> collect1 = studentList.stream()
            .filter(student -> list.contains(student.getClasses()))
            .collect(Collectors.toList());
    for (Student student1 : collect1) {
        System.out.println("student1 = " + student1);
    }
}

打印结果：（点击左侧小三角显示）====================================>

student = Student(name=张三, classes=001, score1=60, score2=80.0, type=0)
student = Student(name=李四, classes=001, score1=62, score2=82.0, type=0)
--------------- 分割线 ---------------
student1 = Student(name=张三, classes=001, score1=60, score2=80.0, type=0)
student1 = Student(name=李四, classes=001, score1=62, score2=82.0, type=0)
student1 = Student(name=齐七, classes=003, score1=68, score2=88.0, type=2)

1.6 分组

/**
 * 分组
 */
@Test
public void test05(){
    List<Student> studentList = getList();

    //简单分组 -- 以班级作为分组条件
    Map<String, List<Student>> collect = studentList.stream().collect(Collectors.groupingBy(Student::getClasses));
    
    collect.forEach((key, value) -> {
        System.out.println("当前班级: [" + key + "], 当前value: " + JSON.toJSONString(value));
    });

    System.out.println("--------------- 分割线 ---------------");

    //嵌套分组 -- 以班级作为分组条件后再以type分组
    Map<String, Map<Integer, List<Student>>> collect1 = studentList.stream()
            .collect(Collectors.groupingBy(
                    Student::getClasses,
                    Collectors.groupingBy(Student::getType)
                    )
            );
    collect1.forEach((key, value) -> {
        value.forEach((key1, value2) -> {
            System.out.println("当前班级: [" + key + "], 当前type: [" + key1 +"] " + JSON.toJSONString(value2));
        });
    });
}

打印结果：（点击左侧小三角显示）====================================>

当前班级: [001], 当前value: [{“classes”:“001”,“name”:“张三”,“score1”:60,“score2”:80.0,“type”:0},{“classes”:“001”,“name”:“李四”,“score1”:62,“score2”:82.0,“type”:0}]
当前班级: [002], 当前value: [{“classes”:“002”,“name”:“王五”,“score1”:64,“score2”:84.0,“type”:0},{“classes”:“002”,“name”:“赵六”,“score1”:66,“score2”:86.0,“type”:1}]
当前班级: [003], 当前value: [{“classes”:“003”,“name”:“齐七”,“score1”:68,“score2”:88.0,“type”:2}]
--------------- 分割线 ---------------
当前班级: [001], 当前type: [0] [{“classes”:“001”,“name”:“张三”,“score1”:60,“score2”:80.0,“type”:0},{“classes”:“001”,“name”:“李四”,“score1”:62,“score2”:82.0,“type”:0}]
当前班级: [002], 当前type: [0] [{“classes”:“002”,“name”:“王五”,“score1”:64,“score2”:84.0,“type”:0}]
当前班级: [002], 当前type: [1] [{“classes”:“002”,“name”:“赵六”,“score1”:66,“score2”:86.0,“type”:1}]
当前班级: [003], 当前type: [2] [{“classes”:“003”,“name”:“齐七”,“score1”:68,“score2”:88.0,“type”:2}]

二、stream进阶玩法

2.1 列求和

/**
 * List 列求和
 * 对score1、score2 求和
 */
@Test
public void test06(){
    List<Student> studentList = getList();
    // 方式1
    Student student = studentList.stream().reduce(new Student(0, 0d), (s1, s2) ->
            new Student(s1.getScore1() + s2.getScore1(), s1.getScore2() + s2.getScore2())
    );
    System.out.println("student = " + student);
    
    System.out.println("--------------- 分割线 ---------------");

    // 方式2
    // 假如求和字段同类型
    int[] reduce = studentList.stream().reduce(new int[]{0, 0},
            (result, student1) -> new int[]{result[0] + student1.getScore1(), (int) (result[1] + student1.getScore2())},
            (result1, result2) -> new int[]{result1[0] + result2[2], result1[1] + result2[1]});
    System.out.println("reduce = " + Arrays.toString(reduce));

}

打印结果：（点击左侧小三角显示）====================================>

student = Student(name=null, classes=null, score1=320, score2=420.0, type=null)
--------------- 分割线 ---------------
reduce = [320, 420]

2.2 flatMap使用

/**
 * flatMap 把每个item为一个流，然后再汇总
 */
@Test
public void test07(){
    List<String> sentences = Arrays.asList("Hello World", "Java Stream Example", "FlatMap Usage");

    List<String> words = sentences.stream()
            .map(sentence -> sentence.split(" ")) // 将句子拆分为单词数组
            .flatMap(Arrays::stream) // 将每个单词数组映射为一个流，并将这些流合并成一个新的流
            .collect(Collectors.toList()); // 将合并后的单词流收集为列表

    System.out.println("words = " + words);
}

打印结果：（点击左侧小三角显示）====================================>

words = [Hello, World, Java, Stream, Example, FlatMap, Usage]

完整代码如下：

import com.alibaba.fastjson2.JSON;
import com.me.domain.Student;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@SpringBootTest
public class StreamTest {

// ============================ stream基础 ==================================

    /**
     * 1、取List中每个item的某一个字段
     * 2、list转map  name作为key, value为student
     */
   @Test
    public void test01(){
       List<Student> studentList = getList();

       // 1、取list中每个item的name字段组成新的list
       List<String> collect = studentList.stream()
                   .map(Student::getName)
                   .collect(Collectors.toList());

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

       // 2、list转map  name作为key, value为student
       Map<String, Student> studentMap = studentList.stream()
                   .collect(Collectors.toMap(Student::getName, student -> student));

       studentMap.forEach((k, v) ->{
           System.out.println("k=" + k + ", v=" + v.toString());
       });
   }
    /**
     * 去重
     */
    @Test
    public void test02(){
        List<String> listStr = getListStr();
        System.out.println("去重前 = " + listStr);
        listStr = listStr.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后=" + listStr);
    }


    /**
     * 排序 -- 根据student的score1降序
     */
    @Test
    public void test03(){
        List<Student> studentList = getList();

        List<Student> collect = studentList.stream()
                .sorted((s1, s2) -> s2.getScore1() - s1.getScore1())
                .collect(Collectors.toList());
        for (Student student : collect) {
            System.out.println("student = " + student);
        }
    }

    /**
     * 过滤 -- 根据List过滤班级（简单使用可以）
     */
    @Test
    public void test04(){
        // 过滤出classes=001和003的学生
        ArrayList<String> list = new ArrayList<>();
        list.add("001");
        list.add("003");
        List<Student> studentList = getList();

        List<Student> collect = studentList.stream()
                .filter(student -> student.getClasses().equals("001"))
                .collect((Collectors.toList()));

        for (Student student : collect) {
            System.out.println("student = " + student);
        }

        System.out.println("--------------- 分割线 ---------------");

        List<Student> collect1 = studentList.stream()
                .filter(student -> list.contains(student.getClasses()))
                .collect(Collectors.toList());
        for (Student student1 : collect1) {
            System.out.println("student1 = " + student1);
        }
    }
    /**
     * 分组
     */
    @Test
    public void test05(){
        List<Student> studentList = getList();

        //简单分组 -- 以班级作为分组条件
        Map<String, List<Student>> collect = studentList.stream().collect(Collectors.groupingBy(Student::getClasses));

        collect.forEach((key, value) -> {
            System.out.println("当前班级: [" + key + "], 当前value: " + JSON.toJSONString(value));
        });

        System.out.println("--------------- 分割线 ---------------");

        //嵌套分组 -- 以班级作为分组条件后再以type分组
        Map<String, Map<Integer, List<Student>>> collect1 = studentList.stream()
                .collect(Collectors.groupingBy(
                        Student::getClasses,
                        Collectors.groupingBy(Student::getType)
                        )
                );
        collect1.forEach((key, value) -> {
            value.forEach((key1, value2) -> {
                System.out.println("当前班级: [" + key + "], 当前type: [" + key1 +"] " + JSON.toJSONString(value2));
            });
        });
    }

// ============================ stream进阶玩法 ==================================
    /**
     * List 列求和
     * 对score1、score2 求和
     */
    @Test
    public void test06(){
        List<Student> studentList = getList();
        // 方式1
        Student student = studentList.stream().reduce(new Student(0, 0d), (s1, s2) ->
                new Student(s1.getScore1() + s2.getScore1(), s1.getScore2() + s2.getScore2())
        );

        System.out.println("student = " + student);
        
        System.out.println("--------------- 分割线 ---------------");

        // 方式2
        // 假如求和字段同类型
        int[] reduce = studentList.stream().reduce(new int[]{0, 0},
                (result, student1) -> new int[]{result[0] + student1.getScore1(), (int) (result[1] + student1.getScore2())},
                (result1, result2) -> new int[]{result1[0] + result2[2], result1[1] + result2[1]});

        System.out.println("reduce = " + Arrays.toString(reduce));

    }
    /**
     * flatMap 把每个item为一个流，然后再汇总
     */
    @Test
    public void test07(){
        List<String> sentences = Arrays.asList("Hello World", "Java Stream Example", "FlatMap Usage");

        List<String> words = sentences.stream()
                .map(sentence -> sentence.split(" ")) // 将句子拆分为单词数组
                .flatMap(Arrays::stream) // 将每个单词数组映射为一个流，并将这些流合并成一个新的流
                .collect(Collectors.toList()); // 将合并后的单词流收集为列表

        System.out.println("words = " + words);
    }
 
    public List<Student> getList(){
        List<Student> studentList = new ArrayList<>(5);
        Student student1 = new Student("张三", "001", 60, 80d, 0);
        Student student2 = new Student("李四", "001", 62, 82d, 0);
        Student student3 = new Student("王五", "002", 64, 84d, 0);
        Student student4 = new Student("赵六", "002", 66, 86d, 1);
        Student student5 = new Student("齐七", "003", 68, 88d, 2);

        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);
        studentList.add(student5);
        return studentList;
    }

    public List<String> getListStr(){
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("C");
        list.add("B");
        list.add("C");
        return list;
    }
}
汤姆的小猫
关注
专栏目录
java8 stream流 （遍历、排序、分组、去重）
dekulugu的博客
11-05 3840
遍历 foreach遍历 list.forEach(str-> System.out.println(str)); 流遍历 List list = new ArrayList(); list.add(“a”); list.add(“b”); list.add(“c”); list.add(“d”); List list3 = new ArrayList(); // 过滤字符串为a的元素 list.stream().filter(str -> !“a”.equals(str)).forEa
java中使用stream()流实现排序、去重、分组、查询和最小值以及最大值和平均值等
shakdkxl的博客
12-07 1672
1、使用forEach()遍历List package com.example.demo.util; import lombok.Data; @Data public class Person { private int id; private String name; private int age; private String sex; private String classroom; public Person(int id, String name, in.
Java8特性：分组、提取字段、去重、过滤、差集、交集
最新发布
weixin_40750633的博客
09-07 497
Java8特性：分组、提取字段、去重、过滤、差集、交集
java8新特性 stream流的方式遍历集合和数组操作
08-18
主要介绍了java8新特性 stream流的方式遍历集合和数组操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java8集合遍历之Stream流
weixin_54394136的博客
04-24 1874
Java8。
Java过滤器
在你最感兴趣的事物上，隐藏着你人生的秘密
03-06 1万+
过滤器就是在源数据和目的数据之间起过滤作用的中间件。        Web应用中，在处理请求时，经常有一些公共的工作，比如设置字符集。这样的工作需要写在每个页面，这样的写法费力且不好修改。使用过滤器就像在这些流程前加了一道拦，将需要进行的操作放到拦里执行，而所有经过这道拦的流程都会“被”执行该操作。             开发一个过滤器必须实现Java定义好的javax.servlet.F
Java 8 流排序
BusyMonkey
10-09 1262
publci class TestBean { private String a; private String b; public TestBean(String a, String b) { this.a = a; this.b = b; } public String getA() { retu...
java8 Stream流排序
capricornce的博客
06-30 377
//按年龄排序(Integer类型)，默认升序 List<StudentInfo> studentsSortName = studentList.stream().sorted(Comparator.comparing(StudentInfo::getAge).reversed()).collect(Collectors.toList()); 加reversed()，反转即降序 //按年龄排序(Integer类型) List<StudentInfo> studentsSor.
JAVA8 Stream流式编程的去重、过滤、映射(map)、分组、统计(sum、max、min、avg)、分页
aplis的博客
08-13 925
Stream提供了两种类型的操作——中间操作和终端操作。中间操作用于链式调用，并可以有多个，而终端操作是触发计算的地方。Stream流的实现原理主要基于迭代器和函数式编程的思想。在内部迭代的过程中，流通过一系列操作进行链式处理，将每个元素传递给下一个操作，并最终生成结果。方法一核心代码：list = list.stream().filter(o -> o.getName()!= null).collect(在并行流的情况下，流将输入数据分成多个小块，分配给不同的线程并行处理。处理完后，再合并结果并返回。
Java stream流集合汇总排序、拼接、过滤、去重、求和、最大值、最小值和平均值等操作
weixin_45409897的博客
03-06 1801
stream流汇总排序,拼接,过滤,去重,求和,最大值,最小值,平均值等操作
JAVA8中Stream的用法之最大、最小、平均值、分组、求和、遍历、过滤、排序
热门推荐
huaiyan
09-20 2万+
JAVA8新特一、根据字段分组根据性别分组效果如图所示二、根据字段求和根据年龄求和效果如图所示三、遍历数据遍历数据效果图四、过滤数据根据年龄字段过滤数据效果五、根据字段求最大最小值根据字段求最大最小值效果图六、根据需求将list转为map根据需求将list转为map效果图七、排序排序效果图八、去重去重效果图 所有的代码均以User对象来做案例,有不对或者错误的地方请各位J友多多担待和指出. 实体类...
Java List stream数据筛选、去重、分组、统计、排序，按小时、天、周、月、年分组统计，最大值、最小值、平均数、求和
weixin_42562567的博客
03-11 3475
Java List数据分组、统计，按小时、天、周、月、年
java8 reduce分组去重
yuhui666666的博客
08-30 360
/优先取同组中时间不为空的。
java stream()过滤
egmjx的博客
11-23 1344
Java strea()过滤
java8遍历_java8中的stream流遍历
weixin_39956443的博客
02-12 622
1 packagecnom.test.testUtils;23 importjava.io.Serializable;4 importjava.util.ArrayList;5 importjava.util.Collections;6 importjava.util.Comparator;7 importjava.util.Iterator;8 importjava.util.List;9 im...
使用java中的流stream快速遍历
qq_45576281的博客
01-20 684
流：顾名思义就像水流，它只流一次，在这一次过程中对其中的元素进行操作。3.如果是集合类，继承了Collection的.strean。实际应用：把数组中的元素的奇数删除再把剩下元素×2再输出。2.使用数组的Arrays.stream。1.使用stream流的of方法。在使用流时，流会一去不复返。
java stream 按条件过滤
weixin_29605669的博客
06-29 267
教你如何在Java中使用Stream按条件过滤 作为一名经验丰富的开发者，我将向你介绍如何在Java中使用Stream按条件过滤数据。首先，我们来整体了解一下这个过程。 流程图 #render_9_3000033807-svg{font-family:"trebuchet ms",verdana,arial,sans-se...
Java-Stream流-概述、创建、使用：遍历/匹配、筛选、聚合、映射、归约、排序、提取/组合
小孔靠得住的博客
05-28 1426
​ Java 8中的Stream流是一种全新的数据处理抽象，它革命性地改变了开发者处理集合数据的方式。Stream API并不是一个真正持有数据的集合，而是一种数据渠道，用于处理具有集合、数组等数据结构支持的数据序列。Stream的核心思想借鉴了函数式编程语言的处理数据方式，强调声明式编程风格，使得开发者能够以更高效、更简洁的方式表达数据处理逻辑。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值