java8的stream流学习(2)

最新推荐文章于 2024-08-16 23:42:19 发布
最新推荐文章于 2024-08-16 23:42:19 发布
阅读量129 收藏
点赞数
分类专栏： javaSE 文章标签： java stream lambda filter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shaoming314/article/details/113092119
版权
本文详细介绍了Java8的Stream流的使用，包括通过集合、数组和Stream.of创建流，以及流的操作如筛选、映射、排序、终止等。通过实例展示了如何过滤、映射、排序学生数据，并进行各种流操作，如查找、匹配、规约和收集。文章旨在帮助读者深入理解Java8的新特性，提高代码编写效率。
摘要由CSDN通过智能技术生成

java8的stream流学习(2)

***前言***

之前也写过两三篇关于Stream相关的帖子,当然了,也是参考的.我感觉java8的新特性还是要深刻掌握的,因为这几个新特性的确能帮助我们让代码变得健壮,不说了,直接写案例,撸代码

参考网址:

https://mp.weixin.qq.com/s/IHkpqdRLeEPAgdPbOnxsKw

准备测试数据

实体类

package com.shaoming.stream3;


import java.util.Objects;

/**
 * @Auther: shaoming
 * @Date: 2021/1/23 14:15
 * @Description:
 */
public class Student implements Comparable<Student>{
    private Integer id;
    private String naem;
    private Integer age;
    private Double score;

    public Student() {
    }

    public Student(Integer id, String naem, Integer age, Double score) {
        this.id = id;
        this.naem = naem;
        this.age = age;
        this.score = score;
    }


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getNaem() {
        return naem;
    }

    public void setNaem(String naem) {
        this.naem = naem;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", naem='" + naem + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }



    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Student)) {
            return false;
        }
        Student student = (Student) o;

        if (id != null ? !id.equals(student.id) : student.id != null) {
            return false;
        }
        if (naem != null ? !naem.equals(student.naem) : student.naem != null) {
            return false;
        }
        if (age != null ? !age.equals(student.age) : student.age != null) {
            return false;
        }
        return score != null ? score.equals(student.score) : student.score == null;
    }

    @Override
    public int hashCode() {
        int result = id != null ? id.hashCode() : 0;
        result = 31 * result + (naem != null ? naem.hashCode() : 0);
        result = 31 * result + (age != null ? age.hashCode() : 0);
        result = 31 * result + (score != null ? score.hashCode() : 0);
        return result;
    }


    @Override
    public int compareTo(Student o) {
        return Double.compare(this.getScore(),o.getScore());
    }
}

造假数据


import java.util.ArrayList;
import java.util.List;
public class StudentData {
    public static List<Student> getStudents(){
        List<Student> list=new ArrayList<Student>();
        list.add(new Student(1,"刘备",18,90.4));
        list.add(new Student(2,"张飞",19,87.4));
        list.add(new Student(3,"关羽",21,67.4));
        list.add(new Student(4,"赵云",15,89.4));
        list.add(new Student(5,"马超",16,91.4));
        list.add(new Student(6,"曹操",19,83.4));
        list.add(new Student(7,"荀彧",24,78.4));
        list.add(new Student(8,"孙权",26,79.4));
        //故意往集合里面放上两个一样的对象
        list.add(new Student(9,"鲁肃",21,93.4));
        list.add(new Student(9,"鲁肃",21,93.4));
        return list;
    } 
}

测试

测试1

创建stream流

package com.shaoming.stream3;

import org.junit.Test;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 创建stream流
 */
public class StreamTest31 {

    /**
     * 方式一：通过一个集合创建Stream
     */
    @Test
    public void test1() {
        List<Student> studentList = StudentData.getStudents();
        //第一种,返回一个顺序流
        Stream<Student> stream = studentList.stream();
        Stream<Student> stream2 = studentList.parallelStream();
    }

    /**
     * 方式二:通过一个数组创建Stream
     */
    @Test
    public void test2() {
        int[] arr = new int[]{1, 2, 3, 4, 6};
        IntStream stream = Arrays.stream(arr);

        Student[] arrStudents = StudentData.getArrStudents();
        Stream<Student> stream1 = Arrays.stream(arrStudents);
    }

    /**
     * 方式三:通过streamof
     */
    @Test
    public void test3() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
        Stream<Student> studentStream = Stream.of(new Student(1, "刘备", 18, 90.4),
                new Student(2, "张飞", 19, 87.4),
                new Student(3, "关羽", 21, 67.4)
        );
    }
     @Test
     public void test4(){
         //每隔5个数取一个,从0开始,此时就是无限循环
//         Stream.iterate(0,t->t+5).forEach(System.out::println);
         //设置5个数取一个,从0开始,只取前5个
//         Stream.iterate(0,t->t+5).limit(5).forEach(System.out::println);
         //取出一个随机数
           Stream.generate(Math::random).limit(5).forEach(System.out::println);
     }

}

测试2

使用stream操作数据

package com.shaoming.stream3;

import org.junit.Test;

import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Stream;

/**
 * 使用stream操作数据
 */
public class StreamTest32 {
    /**
     * 操作1:筛选和切片
     */
    @Test
    public void test1() {
        List<Student> list = StudentData.getStudents();
        //(1)过滤:过滤出所有年龄大于20岁的同学
        list.stream().filter(item -> item.getAge() > 20).forEach(System.out::println);
        System.out.println();
        //(2)截断流:筛选出前3条数据
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();
        //(3)跳过元素:跳过前5个元素
        list.stream().skip(5).forEach(System.out::println);
        System.out.println();
        //(4)过滤重复元素
        list.stream().distinct().forEach(System.out::println);
        System.out.println();
    }

    /**
     * 操作2:映射
     */
    @Test
    public void test2() {
        //(1)map操作
        List<String> list = Arrays.asList("java", "python", "go");
        Stream<String> stream = list.stream();
        //此时每个小写字母都有一个大写映射
        stream.map(str->str.toUpperCase()).forEach(System.out::println);
    }
    /**
     * 操作3:排序
     */
    @Test
    public void test3(){
        //(1)自然排序
        List<Integer> list = Arrays.asList(4, 3, 7, 9, 12, 8, 23, 2);
        Stream<Integer> stream = list.stream();
        stream.sorted().forEach(System.out::println);
        //(2)对象排序:对象类可以先实现comparable接口,或者直接指定
        //第一种:先实现compable接口
//        List<Student> studentList = StudentData.getStudents();
//        studentList.stream().sorted().forEach(System.out::println);
        //第二种:直接指定comparable
        List<Student> studentList1 = StudentData.getStudents();
        studentList1.stream().sorted((e1,e2)->Integer.compare(e1.getAge(),e2.getAge())).forEach(System.out::println);
    }
}

测试3

终止stream

package com.shaoming.stream3;

import com.shaoming.ifelse.StudentLevel;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 终止stream
 */
public class StreamTest33 {
    /**
     * 操纵1:匹配和查找
     */
    @Test
    public void test1() {
        List<Student> list = StudentData.getStudents();
        //(1)判断所有的学生年龄是都都大于20岁
        boolean allMatch = list.stream().allMatch(item -> item.getAge() > 20);
        //(2)判断是否存在学生的年龄大于20
        boolean anyMatch = list.stream().anyMatch(item -> item.getAge() > 20);
        //(3)判断是否存在学生叫曹操
        boolean noneMatch = list.stream().noneMatch(item -> item.getNaem().equalsIgnoreCase("曹操"));
        //(4)查早第一个学生
        Optional<Student> first = list.stream().findFirst();
        Student student = first.get();
        Optional<Student> first1 = list.stream().sorted
                ((e1, e2) -> Double.compare(e1.getScore(), e2.getScore())).collect(Collectors.toList()).stream().findFirst();
        Student student1 = first1.get();
        System.out.println(student);
        System.out.println(student1);
        //(5)查找所有学生的数量
        long count = list.stream().count();
        long count1 = list.stream().filter(item -> item.getScore() > 90).count();
        //(6)查找当前流中的元素
        Optional<Student> any = list.stream().findAny();
        //(7)查找学生最高的分数:Student实现了comparable接口的话,可直接比较
        Stream<Double> doubleStream = list.stream().map(item -> item.getScore());
    }

    /**
     * 自定义比较器
     */
    @Test
    public void test2222() {
        List<Student> list=new ArrayList<Student>();
        list.add(new Student(1,"刘备",18,90.4));
        list.add(new Student(1,"刘备",19,90.4));
        list.add(new Student(1,"刘备",20,80.4));
         list.stream().sorted
                ((e1, e2) -> {
                    if (e1.getScore().equals(e2.getScore())) {
                        return Integer.compare(e1.getAge(), e2.getAge());
                    } else {
                        return -Double.compare(e1.getScore(), e2.getScore());
                    }
                }).collect(Collectors.toList()).forEach(System.out::println);
        System.out.println();
    }
    /**
     * 操作2:规约
     */
    @Test
    public void test2(){
        //(1)计算数的总和
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println("总和为: "+sum);
        //(2)计算学生总分
        List<Student> studentList = StudentData.getStudents();
        Stream<Double> doubleStream = studentList.stream().map(Student::getScore);
        Optional<Double> scoreSum = doubleStream.reduce(Double::sum);
        System.out.println("分数的总和为:"+scoreSum);
    }
    /**
     * 操作3:收集
     */
    @Test
    public void test3(){
        List<Student> studentList = StudentData.getStudents();
        //返回一个list集合
        studentList.stream().filter(e->e.getAge()>18).collect(Collectors.toList()).forEach(System.out::println);
        System.out.println();
        //返回一个set
        studentList.stream().filter(e->e.getAge()>18).collect(Collectors.toSet()).forEach(System.out::println);
    }
}
小杆子314
关注
专栏目录
JAVA8--Stream流
搞事情的博客
08-13 1098
Stream流 在JAVA8中添加Stream，这个真的是一个好东西。学习使用Stream会有效提高开发效率。究竟流有什么用呢？简单来说就是从数据源当中处理操作并输元素序列的一个东西，好像说得不太好。来段代码看看吧！我们有一个列表，里面筛选出女同学放到另外一个列表当中，以前我们是这样做的。 先给出一个实体Student类（这个实体类会在例子当中使用） public class Studen...
Java8 Stream学习
01-05
### Java8 Stream学习 #### 一、Stream简介 在Java8中，Stream 是一项重要的新增特性，它提供了一种全新的处理集合数据的方式。不同于传统的集合类（如List、Set等），Stream API支持更加灵活的数据处理方式，使得...
《算法》2.1~2算法进阶之路-排序
页川叶川
06-12 762
二、排序 排序算法类的模板 大多数情况下，我们所实现的排序算法只会通过两个方法操作数据：**less()方法对元素进行比较，exch()方法将元素交换位置。exch()方法的实现很简单，通过Comparable接口实现less()方法也不困难。sort()方法**非常重要，它决定着算法执行所需要的时间，不同的算法对sort()有不同的实现，sort()方法将是我们本节讨论的重点。 **注意:相信...
Java Sort排序总结
qq_26457825的博客
06-23 1万+
数组Sort排序 正序排序：Arrays.sort(array)，会检查数组个数大于286且连续性好就使用归并排序，若小于32使用插入排序，其余情况使用快速排序 int[] array = {10, 3, 6, 1, 4, 5, 9}; Arrays.sort(array); 降序排序：先将数组Arrays.asList()转为集合，然后使用Collections.reverse()反转集合，注意如果是基础数据类型（不是数据包装类），不能使用Arrays.asList()方法可以使用Guava的Int..
java8中一个极其强悍的新特性Stream（非常实用）
Allenlzcoder的博客
03-02 560
本博客系转载：https://zhuanlan.zhihu.com/p/97493325添加链接描述 1.Stream语法讲解 Stream执行流程很简单，主要有三个，首先创建一个Stream，然后使用Stream操作数据，最后终止Stream。有点类似于Stream的生命周期。下面我们根据其流程来一个一个讲解。 前提准备，首先我们创建一个Student类，以后我们每次都是操作这个类。 publi...
java的各种排序方法..
卡卡的专栏
08-09 810
用Java语言实现的各种排序，包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。插入排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/** * @author treeroot * @since 2006-2-2 * @version 1
【Java学习】Stream流详解
最新发布
2202_76097976的博客
08-16 1699
Stream流是JDK 8引入的一个概念，它提供了一种高效且表达力强的方式来处理数据集合（如List、Set等）或数组。Stream API可以以声明性方式（指定做什么）来处理数据序列。流操作可以被分为两大类：中间操作（Intermediate Operations）和终端操作（Terminal Operations）。
Java Stream流详解
唯有努力，方可自信！
06-10 3万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
Java8 Stream 流
weixin_44061521的博客
12-24 2641
简介 Java8两大新特征，一是支持 lambda 表达式，二是 Stream API。在使用 Stream API 之前，最好有 lambda表达式的基础，如果不太清楚，可以看我的另一篇博客lambda表达式。 在编写代码的过程中，我们经常要对集合或数组数据进行操作，而有了 Stream API，我们能够非常轻松的对集合、数据进行映射、过滤、查找等操作，使得我们能够像操作数据库一样的操作集合。 Stream 本身并不存储元素，它并不改变源数据，每次操作都会形成一个新的流，并且只有执行了Stream的终止操
Java 8 Stream常用方法学习
热门推荐
Java小皮孩
01-21 3万+
Stream Stream流是 Java8 API 新增的一个处理集合的关键抽象概念，是一个来自数据源的元素队列并支持聚合操作。以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。 相关名词 描述 元素 对象形成的一个队列。 Java中的Stream并不会存储元
Java8中的Stream流相关用法学习
林隐的博客
04-29 754
Java8中的Stream流相关用法学习
java8 stream 由一个list转化成另一个list案例
08-24
今天，我们学习了如何使用 Java8 Stream 将一个 List 转化成另一个 List，同时还学习了一些其他的应用，例如使用 Stream().forEach() 循环处理 List、使用 Stream().map() 处理 List，并给另外一个 List 赋值、使用 ...
Java8中Stream使用的一个注意事项
08-28
Java 8 中的 Stream 是一个强大的工具，它引入了一种新的数据处理方式，特别是对于集合对象的操作。Stream 不是存储数据的数据结构，而是用于处理数据的 API，它提供了丰富的操作，如过滤、映射、聚合等，使得代码...
Java8新特性之方法引用&Stream流应用实例md，学习代码
06-21
以上就是关于Java 8方法引用和Stream流的基本介绍及其应用实例。理解并熟练运用这两个特性，能让你的Java代码变得更加简洁、高效。在实际项目中，如Tomcat服务器的配置、Cookie、Session与Web存储的管理等方面，都...
Java8特性Stream流的使用（学完就会，项目源码，附带个人总结）
09-09
以下将详细介绍Stream流的使用，以及它在Java8中的重要性。 首先，Stream API是一种用于处理集合的新接口，它可以对集合进行各种操作，如过滤、映射、聚合等，而无需显式地遍历集合。这种处理方式称为“函数式编程...
stream进行分页
java技术博客
04-19 8277
stream进行分页 说明: 最近看了一篇关于java8的StreamAPI使用的文章,正好看到一个和分页查询相关的api,由此写一个demo,加深对StreamAPI的印象 模拟dao层从数据库获取数据 实体类 User @Data @AllArgsConstructor @NoArgsConstructor public class User { private Integer id; private String name; private String address;
java常用工具类和Hutool常用的工具类整理
java技术博客
08-30 4468
java常用工具类和Hutool常用的工具类整理 1.java常用工具类 1.1 Scanner类 /** * Scanner 类 */ @Test public void testScanner() { Scanner scanner = new Scanner(System.in); System.out.println("请输入一个数字: "); int sc = scanner.nextInt(); System.out.println(sc); } 1.2Rando
java对象和json转换三种工具类汇总
java技术博客
04-25 1978
java对象和json转换三种工具类汇总 说明: 去年的时候就像总结json工具类的,不然每次用到都需要百度,好麻烦,这次总结了三种工具类详细的用法 准备工作 1.准备springboot工程 2.引入依赖 jackson是springboot默认json转换方式的工具类 Gson,是google的json工具类,我们需要自己引入 FastJson是阿里的json工具类,需要问哦们手动引入 <?xml version="1.0" encoding="UTF-8"?> <project
list元素修改属性返回新list
java技术博客
09-12 1917
list元素属性操作后返回新list 说明: 本机一定要装java8环境，这里面使用了jdk1.8的新特性，stream流 准备工作 java8环境 新建一个实体类Emp.java package com.shaoming; /** * @ClassName: Emp * @Author: 邵明 * @Date: 2021/9/12 01:14 * @Description: */ public class Emp { private Integer id; private
Java8 Stream流操作详解
"JavaStream流是Java8引入的新特性，配合Lambda表达式，为集合操作提供了高效且简洁的方式。Stream不存储数据，而是通过中间操作定义处理逻辑，并在终端操作时执行。它具有延迟执行和不可变性，常用于数据过滤、排序...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值