Stream 流的使用

最新推荐文章于 2024-07-10 11:24:06 发布
最新推荐文章于 2024-07-10 11:24:06 发布
阅读量223 收藏 2
点赞数
分类专栏： java 文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46159525/article/details/113794729
版权
  • Stream 关注的是对数据的运算，和 cpu 打交道，而集合关注的则是数据的存储，与内存打交道
  • stream 自己不会存储元素
  • stream 不会改变源对象，相反，他会返回一个持有结果的新的 stream
  • stream 操作是执行的，这意味着他们会等到需要结果的时候才执行
  • 执行流程
    1. stream 的实例化
    1. 中间的一系列操作（过滤，映射
    1. 终止操作
  • 说明 :
    1. 一个中间操作链，对数据源的数据进行处理
    1. 一旦执行终止操作，就执行中间的操作链，并产生结果集，之后不再被使用

两个工具类：
Student:

public class Student {

    int no;
    String name;
    String sex;
    float height;

    public Student(int no, String name, String sex, float height) {
        this.no = no;
        this.name = name;
        this.sex = sex;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", height=" + height +
                '}';
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public float getHeight() {
        return height;
    }

    public void setHeight(float height) {
        this.height = height;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return no == student.no &&
                Float.compare(student.height, height) == 0 &&
                Objects.equals(name, student.name) &&
                Objects.equals(sex, student.sex);
    }

    @Override
    public int hashCode() {
        return Objects.hash(no, name, sex, height);
    }
}

ListAddUtil：

public class ListAddUtil {

    public static List<Student> addObject(){
        Student stuA = new Student(1, "A", "M", 184);
        Student stuB = new Student(2, "B", "G", 163);
        Student stuC = new Student(3, "C", "M", 175);
        Student stuD = new Student(4, "D", "G", 158);
        Student stuE = new Student(5, "E", "M", 170);
        List<Student> list = new ArrayList<>();
        list.add(stuA);
        list.add(stuB);
        list.add(stuC);
        list.add(stuD);
        list.add(stuE);
        return list;
    }

}

 
 

1. 创建流的四种方式
public class StreamApi {


    // 创建 stream 方式一：通过集合
   @Test
    public void test(){
      List<Student> students = ListAddUtil.addObject();

      // 该结果返回一个顺序流
      Stream<Student> stream = students.stream();

      //返回一个并行流
      Stream<Student> studentStream = students.parallelStream();
   }

   // 创建 stream 方式二：通过数组创建

   public void test1(){
      int[] ints = {1, 2, 3, 4};

      IntStream stream = Arrays.stream(ints);
   }

   // 创建 stream 方式三：通过 stream 的 of 方式
   @Test
   public void test2(){
      Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
   }

   // 创建 stream 方式四：创建无线流
   @Test
   public void test3(){

      // 迭代
      // 遍历前十个偶数
      Stream.iterate(0,num->num+2).limit(10).forEach(System.out::println);

      // 生成
      Stream.generate(Math::random).forEach(System.out::println);

   }

}

 
 

2. Stream 中间操作

 
筛选与切片：

@Test
    public void test() {
        List<Student> students = ListAddUtil.addObject();
        // filter,从流中排出某些元素
        Stream<Student> stream = students.stream();
        stream.filter(s -> s.getSex().equals("M")).forEach(System.out::println);

        System.out.println("*********************************************");

        // limit 截断流 使其元素不超过给定的数量
        students.stream().limit(2).forEach(System.out::println);

        System.out.println("*********************************************");
        // skip(n) 跳过元素，返回一个扔掉前 n 个元素的流，若元素不足 n 个 ，则返回一个空流
        students.stream().skip(3).forEach(System.out::println);

        // distinct() 筛选，通过流生成元素的 hashCode() 和 equals() 去除重复的元素

        System.out.println("************************");

        students.add(new Student(1, "A", "M", 184));
        students.add(new Student(1, "A", "M", 184));
        students.add(new Student(1, "A", "M", 184));
//        System.out.println(students.size());
        students.stream().distinct().forEach(System.out::println);


    }

 
映射：

 @Test
    public void test1() {

        // map(Function f) 接受一个函数作为参数，将元素转换成其他形式或提取信息
        List<String> list = Arrays.asList("aa", "bb", "cc");
        list.stream().map(String::toUpperCase).forEach(System.out::println);

        System.out.println("》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》");

        List<Student> students = ListAddUtil.addObject();

        students.stream().map(Student::getName).filter(s -> s.equals("A")).forEach(System.out::println);

        System.out.println("》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》");

        Stream<Stream<Character>> streamStream = list.stream().map(StreamApi1::fromStringToStream);

        streamStream.forEach(s -> s.forEach(System.out::println));


        // flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流
        System.out.println("》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》");
        Stream<Character> characterStream = list.stream().flatMap(StreamApi1::fromStringToStream);
        characterStream.forEach(System.out::println);

    }

    // 将字符串中的多个字符构成的集合转换为对应的 steam 流实例

    public static Stream<Character> fromStringToStream(String s) {
        ArrayList<Character> arrayList = new ArrayList<>();

        for (char c : s.toCharArray()) {
            arrayList.add(c);
        }

        return arrayList.stream();

    }


    @Test
    public void test3() {
        List list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);


        List list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);

        //list1.add(list2);
        list1.addAll(list2);
        System.out.println("list1 = " + list1);
        System.out.println("list2 = " + list2);
    }

 
排序：

 // 排序
    @Test
    public void test4(){
        // sorted() 自然排序
        List<Integer> integerList = Arrays.asList(12, 56, 34, 78, 1, 102);
        integerList.stream().sorted().forEach(System.out::println);
        System.out.println("***************************************************");
//       出现异常，原因没有实现 Comparable 接口
//        List<Student> students = ListAddUtil.addObject();
//        students.stream().sorted().forEach(System.out::println);


        // sorted(Comparator com) 定制排序
        List<Student> students = ListAddUtil.addObject();
//        students.stream().sorted((s1,s2)->
//            Double.compare(s1.getHeight(),s2.getHeight())
//        ).forEach(System.out::println);

        students.stream().map(Student::getHeight).sorted(Double::compare).forEach(System.out::println);

    }

 
 

3. stream 的终止操作

 
匹配和查找：

 @Test
    public void test() {
        List<Student> students = ListAddUtil.addObject();
        // allMatch 检查是否匹配所有元素
        // 所有元素的 NO 是否大于 10
        boolean allMatch = students.stream().allMatch(student -> student.getNo() > 0);
        System.out.println("allMatch = " + allMatch);

        System.out.println("******************************");

        // anyMatch 检查是否至少匹配一个元素
        boolean anyMatch = students.stream().anyMatch(student -> student.getNo() > 4);
        System.out.println("anyMatch = " + anyMatch);

        System.out.println("******************************");

        // noneMatch 检查是否没有匹配的元素
        boolean noneMatch = students.stream().noneMatch(student -> student.getName().equals("A"));
        System.out.println("noneMatch = " + noneMatch);

        System.out.println("******************************");

        // findFirst 返回第一个元素
        Optional<Student> first = students.stream().findFirst();
        System.out.println("first = " + first);

        System.out.println("******************************");

        // findAny 返回当前流中的任意一个元素
        Optional<Student> any = students.parallelStream().findAny();
        System.out.println("any = " + any);

        System.out.println("******************************");

        // count 返回流中元素的总数
        long count = students.stream().filter(student -> student.getNo() > 2).count();
        System.out.println("count = " + count);

        System.out.println("******************************");

        // max 返回流中最大值
        Stream<Float> floatStream = students.stream().map(student -> student.getHeight());
        System.out.println(floatStream.max(Double::compare));

        System.out.println("******************************");

        // min  返回流中最小值
        Optional<Student> max = students.stream().min((s1, s2) -> Double.compare(s1.getHeight(), s2.getHeight()));
        System.out.println("max = " + max);

        System.out.println("******************************");

        // forEach 内部迭代
        students.stream().forEach(System.out::println);
        // 使用集合的遍历操作
        students.forEach(System.out::println);

    }

 
约规：

 @Test
    public void test2(){
        // reduce(T identity, BinaryOperation) 可以将流中的元素反复结合起来，得到一个值
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4);
        Integer reduce = integerList.stream().reduce(10, Integer::sum);
        System.out.println("reduce = " + reduce);

        // reduce(BinaryOperation) 可以将流中的元素反复结合起来，得到每一个值，返回一个 Optional<T>

        List<Student> students = ListAddUtil.addObject();
        // 方式一：
       // Optional<Float> reduce1 = students.stream().map(Student::getHeight).reduce((h1, h2) -> h1 + h2);

        Optional<Float> reduce1 = students.stream().map(Student::getHeight).reduce(Float::sum);
        System.out.println(reduce1);

    }

 

收集：

@Test
    public void test4(){
        // collect(Collector c) 将流转换为其他形式

        List<Student> students = ListAddUtil.addObject();
        List<Student> collect = students.stream().filter(student -> student.getNo()>3).collect(Collectors.toList());
        collect.forEach(System.out::println);

        System.out.println("**************************");

        students.stream().collect(Collectors.toSet()).forEach(System.out::println);
    }
光头小小强007
关注
专栏目录
Stream流简单使用
QQQQQQQQYY的博客
03-27 855
Stream流作为1.8新特性，在敲代码时带来了全新的体验和更实际运用的场景 一、特点： 1.只能遍历一次： 从数据源中制造一条数据流，依次对流中的元素进行操作，当元素经历过流，便无法再对这条流进行操作 2.采用内部迭代的方式 相比与Collection，是使用Iterator遍历器进行处理，Collection是一种外部迭代 而对于Stream,只要申明处理方式，处理过程在流中自行完成，这是一种内部迭代，在数据量大与高并发场景，内部迭代比外部迭代更加高效 二、优点 无存储......
Java8新特性Stream流的概念和使用【详解】
weixin_65657777的博客
05-24 3978
🎉博客首页：痛而不言笑而不语的浅伤 📢欢迎关注🥳点赞 👍 收藏 ⭐留言 📝 欢迎讨论！ 🔮本文由痛而不言笑而不语的浅伤原创，CSDN首发！ 🌋系列专栏：《JavaSE系列详解》 🧿首发时间：2022年5月24日 ❤：热爱Java学习，期待一起交流！ 🙏🏻作者水平有限，如果发现错误，求告知，多谢！ 🥰有问题可以私信交流！！！ 目录 引言 Stream流的概念 为什么要使用Stream流？ Stream的两个基础的特征: Stream流的获取 通过Collection集合获取.
【Stream流的使用】
最新发布
z1521907的博客
07-10 347
Stream流的使用
Stream流使用
小何的博客
05-17 250
Stream流使用
stream流的使用
苦夏的博客
07-09 213
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 可以用来筛选数据，遍历集合 public void testStream() { List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); Collections.addAll(list, 22,33,11,55); ...
java Stream 流使用
04-15
虽然Stream的语法可能在初看时显得复杂，但随着熟练度的提升，你会发现它提高了代码的简洁性和可读性，尤其在处理大量数据时，使用并行流可以显著提升性能。 要完全掌握Stream的使用，需要熟悉各种操作方法以及它们...
stream流的简单使用
06-05
Stream流的简单使用 Stream流是一种强大的数据处理工具，广泛应用于Java开发中。在本资源中，我们将通过一个简单的示例来介绍Stream流的基本使用。 Person类定义 首先，我们需要定义一个Person类，用于存储人员...
Java Stream 流实现合并操作示例
08-19
在上面的示例中，我们使用 concat 方法将两个 Stream 流合并成一个流，然后将其收集到一个列表中。 多个流的合并 如果我们需要合并多个流，可以使用 concat 方法进行“套娃操作”，例如： ```java Stream...
Stream流基础使用指南
Stay Hungry, Stay Foolish!
10-04 819
文章目录1.1 引言1.2 Stream流概述1.3 获取流（1）Collection获取流（2）Map获取流（3）数组获取流1.3 中间操作（1）filter 过滤（2）map 映射（3）limit 截取（4）sorted 排序（5）distinct 去重（6）skip 跳过1.4 终端操作（1）forEach（2）collect（3）count（4）reduce1.5 总结参考资料 在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。
Stream流的使用
weixin_50458070的博客
01-07 77
Stream流的使用
Stream流的使用（java）
hbdhaj的博客
08-10 2619
1.1 体验Stream流 需求： 按照下面的要求完成集合的创建和遍历 创建一个集合，存储多个字符串元素 把集合中所有以“张”开头的元素存储到一个新的集合 把“张”开头的集合中的长度为3的元素存储到一个新的集合 遍历上一步得到的集合 使用Stream流的方式完成过滤操作 list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
Stream流的使用及详解（上）
am的博客
02-01 1155
```java boolean result = list.stream() .allMatch(Person::isStudent); ```
Stream流的用法(基础)
qq_39378056的博客
08-30 325
import lombok.Data; import org.junit.Test; import java.util.*; import java.util.stream.Collectors; /** * 官方api文档：https://www.oracle.com/java/technologies/javase/8-whats-new.html * 记录stream的用法 * 简介： * Stream是Java8 新增的流特性，目的是让程序员写出高效率、干净、简洁的代码
Stream流的基本使用
seelune_的博客
04-16 463
Stream基本使用，包括一些常用方法和注意事项，并结合一道综合应用巩固
stream流使用详解
09-21
1. 只能遍历一次：一旦对Stream流进行了遍历操作，就无法再次使用，需要重新创建新的Stream流。 Stream流的使用步骤如下： 1. 创建数据源：可以是集合、数组、IO等。 2. 对数据源进行中间操作：可以使用filter()、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

光头小小强007

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值