章十四、Java8Stream —— Stream、获取流、流操作

于 2024-05-19 14:11:10 发布
阅读量729 收藏 8
点赞数 9
文章标签： java 前端 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/king_faner/article/details/139035487
版权

一、 Stream

        Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。

要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念

例：

public static void main(String[] args) {
    List<Apple> applestore = new ArrayList();
    applestore.add(new Apple(1,"red",500,"河南"));
    applestore.add(new Apple(2,"red",400,"陕西"));
    applestore.add(new Apple(3,"green",300,"上海"));
    applestore.add(new Apple(4,"green",200,"湖北"));
    applestore.add(new Apple(5,"green",100,"湖南"));
}

我们的需求是在 applestore 集合中找出红色苹果手机

使用 Stream 流快速实现操作

List<Apple> apples = applestore
    .stream()
    .filter(a -> a.getColor().equals("red"))
    .collect(Collectors.toList())

        这里使用的就是 Java8 中的 stream 流，使用的是声明性方式写的：说明想要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。同时可以将这些操作链接起来，达到一种流水线式的效果：

Java8 中的集合支持一个新的 Stream 方法，它会返回一个流。

什么是流呢？

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。

元素列表:和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

数据源 :获取数据的源，比如集合。

数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。

        简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合

语法:

stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|+
List<Integer> list =
    widgets.stream()
    .filter(b -> b.getColor() == RED)
    .sorted((x,y) -> x.getWeight() - y.getWeight())
    .sum();

二、 获取流

●  使用 Collection 接口下的 stream()

List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();

●  使用 Arrays 中的 stream() 方法，将数组转成流

Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);

●  使用 Stream 中的静态方法：of()

Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

●  使用 BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));
Stream<String> lineStream = reader.lines();

三、 流操作

流操作可以分为两类：中间操作和终端操作。回看之前的代码：

List<Apple> apples = applestore

        .stream() //获得流

        .filter(a -> a.getColor().equals("red")) //中间操作

        .collect(Collectors.toList()); //终端操作

简化一下就是：

        数据源 => 中间操作 => 终端操作 => 结果

        诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终

端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。

●  中间操作

filter：过滤流中的某些元素,

sorted(): 自然排序，流中元素需实现 Comparable 接口

distinct: 去除重复元素

limit(n): 获取 n 个元素

skip(n): 跳过 n 元素，配合 limit(n)可实现分页

map(): 将其映射成一个新的元素

import java.util.Arrays;

public class Demo2 {
    /*
    中间操作
    filter：过滤流中的某些元素,

    sorted(): 自然排序，流中元素需实现 Comparable 接口

    distinct: 去除重复元素

    limit(n): 获取 n 个元素

    skip(n): 跳过 n 元素，配合 limit(n)可实现分页

    map(): 将其映射成一个新的元素

     */
    public static void main(String[] args) {
        Integer[] array = new Integer[]{1,2,3,4,3,5};
        //long sum =  Arrays.stream(array).sorted().count();//链式调用

        //过滤
        Arrays.stream(array)
                .filter((e)->{
                    return e<5; //过滤（筛选得到）小于5的
                })
                .sorted((o1,o2)->{
                    return o2-o1; // 或降序排序
                }) //排序（默认是升序）
                .distinct() //去除重复元素
                .forEach((e)->{ //遍历
                    System.out.println(e);
                });
        Arrays.stream(array)
                .skip(4) //跳过4个元素
                .limit(2)//获取两个元素 如果不足，则只获取能获取的
                .forEach((e)->{
                    System.out.println(e);
                });
    }
}

●  终端操作

forEach: 遍历流中的元素

toArray:将流中的元素倒入一个数组

Min:返回流中元素最小值

Max:返回流中元素最大值

count:返回流中元素的总个数

Reduce:所有元素求和

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false

allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false

findFirst：返回流中第一个元素

collect:将流中的元素倒入一个集合,Collection 或 Map

import java.util.Arrays;
import java.util.Optional;

public class Demo3 {
    /*
    终端操作
    forEach: 遍历流中的元素
    toArray:将流中的元素倒入一个数组
    Min:返回流中元素最小值
    Max:返回流中元素最大值
    count:返回流中元素的总个数
    Reduce:所有元素求和
    anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false
    allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false
    findFirst：返回流中第一个元素
    collect:将流中的元素倒入一个集合,Collection 或 Map
     */
    public static void main(String[] args) {

        Integer[] array = new Integer[]{1,2,3,5,3,4,5};
        Integer max = Arrays.stream(array)
                .distinct() //去重
                .max((o1,o2)->{ //最大值
                    return o1-o2;
                }).get();
        System.out.println(max);

        Integer min = Arrays.stream(array)
                .distinct() //去重
                .min((o1,o2)->{ //最小值
                    return o1-o2;
                }).get();
        System.out.println(min);

        long count = Arrays.stream(array)
                .distinct()
                .count(); //统计元素个数
        System.out.println(count);

        long sum = Arrays.stream(array)
                .distinct()
                .reduce((a,b)->{return a+b;}).get(); //求和
        System.out.println(sum);

        boolean result1 = Arrays.stream(array)
                .distinct()
                .anyMatch((e)->{ // 只要有一个元素满足条件都返回true
                    return e>=2; //反之返回false
                });
        System.out.println(result1);

        boolean result2 = Arrays.stream(array)
                .distinct()
                .allMatch((e)->{ // 所有元素都满足条件返回true
                    return e>=2; //反之返回false
                });
        System.out.println(result2);


    }
}

对于类对象：

Student类

public class Student {
    private int num;
    private String name;
    private int age;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public Student() {
    }

    public Student(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类： 

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

public class Demo4 {
    public static void main(String[] args) {

        Student s1 = new Student(101,"张三1",18);
        Student s2 = new Student(102,"张三2",19);
        Student s3 = new Student(103,"张三3",20);
        Student s4 = new Student(104,"张三4",21);
        Student s5 = new Student(105,"张三5",22);

        ArrayList<Student> students = new ArrayList<>();
        students.add(s2);
        students.add(s3);
        students.add(s1);
        students.add(s5);
        students.add(s4);

        List<Student> students1 = students.stream()
                .distinct() // 去重
                .sorted((stu1,stu2)->{
                    return stu1.getNum()-stu2.getNum();
                })   //排序
                .collect(Collectors.toList()); //将流中的元素倒入一个集合
        System.out.println(students1);

        Object[] array = students.stream()
                .map(Student::getNum) //将getNum()方法传进去
                .toArray();
        System.out.println(Arrays.toString(array));
    }
}

 

三木几
关注
Java8新特性---流
Coder_py的博客
04-29 940
一、Java8流的引入 对于Java的开发者来说，Java集合的使用是再熟悉不过了。几乎每个Java应用里面都或多或少的会制造和处理集合。但在Java8之前对于集合的操作并不是那么的完美，许多时候你需要书写很多的重复代码来实现对集合的操作，所以Java8引用了流的概念来帮你更优雅的处理集合。 二、流是什么 流是Java API的新成员，它允许你以声明性方式处理数据集合（通过查询语句来表达，而不 是...
Java8——Stream流详解
weixin_44863459的博客
08-27 2173
Stream
Stream
m0_49797779的博客
01-07 288
什么是 Stream？ Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后 编码效率与大大提高，并且可读性更强。 要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream(IO中对文件的输入输出) 是完全不同的概念. steam擅长对数据的操作. 简单案例: import java.util.ArrayList; import java.util.
Java8实战——Stream-流的概念
SmartTxp的博客
01-19 239
流 集合与流 流操作 一、流 概念： 从支持数据处理操作的源生成的元素序列 元素序列：流提供了一个接口，可以访问特定元素类型的一组有序值。何谓有序，就是说我们一般是按顺序取用值，而不是随机取用的。 源：流会使用一个提供数据的源，如集合、数组、输入/输出资源；从有序集合生成流，会保留原有顺序；由列表生成的流，七元素顺序与列表一致 数据处理操作：流的数据处理功能支持类似数据的操...
Java8---Stream的介绍和相关概念（1）
IT云清
11-15 986
Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation
java8 笔记 - 流的概念（六）
lilongjiu的专栏
09-25 204
Stream概念
Java——Stream流
m0_72786443的博客
09-13 1357
Stream流
Java8 Stream —— 更丝滑的集合操作方式
superSubfn
12-27 592
一.概念 Stream是一种可供流式操作的数据视图有些类似数据库中视图的概念它不改变源数据集合如果对其进行改变的操作它会返回一个新的数据集合。 总的来讲它有三大特性：在之后我们会对照着详细说明 1、stream不存储数据 2、stream不改变源数据 3、stream的延迟执行特性 二.优点 1、代码简洁，函数式编程写出的代码简...
java 8 新特性（四）——Stream流
weixin_45974176的博客
10-12 191
简介 Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处
Java笔记——Lambda表达式和Stream流
weixin_44853206的博客
11-24 752
/ 测试类 public class Demo03LambdaBase {// 匿名内部类的方式 fun(new MyFunctionalInter() {System . out . println("匿名内部类的方式！");} });// Lambda表达式的标准格式的方式 fun(() -> {System . out . println("Lambda表达式的标准格式的方式");});
Java 8 学习笔记4——流的概念
Willow的博客
12-12 366
流是什么 流是Java API的新成员，它允许你以声明性方式处理数据集合（通过查询语句来表达，而不是临时编写一个实现）。 就现在来说，你可以把它们看成遍历数据集的高级迭代器。此外，流还可以透明地并行处理，你无需写任何多线程代码了！我们简单看看使用流的好处吧。 下面两段代码都是用来返回低热量的菜肴名称的，并按照卡路里排序，一个是用Java 7写的，另一个是用Java 8的流写的。 Java 7： L...
Java8新特性之Stream介绍
fiveSix
01-14 2547
文章目录一、Stream简介二、Stream的构成及操作类型1、Stream构成2、操作类型三、Stream常用属性1、collect 收集属性2、map / flatMap 映射转换3、filter 过滤属性4、forEach / peek 遍历属性5、reduce 聚合属性6、sorted 排序属性7、match 匹配属性 一、Stream简介 Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。 Java
java 8 Stream概述
weixin_43183496的博客
08-23 138
1, 什么是Stream？ Stream将要处理的元素集合看作一种流，在流的过程中， 借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。 2 ,Stream可以由数组或集合创建，对流的操作分为两种： 2.1中间操作，每次返回一个新的流，可以有多个。 2.2 终端操作，每个流只能进行一次终端操作， 终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值 3 ,Stream有几个特性： 3.1stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。 3.2str
Java 8中Stream指什么呢？
qq_25073223的博客
09-26 231
Java 8中Stream的简介说明
Java 8 Stream流底层原理
huang714的专栏
12-15 470
Java 8 Stream流底层原理
探索Java 8新特性：流式编程（Stream流）
m0_50033700的博客
08-14 1625
简要介绍Java 8中引入的流式编程特性，探讨流式编程的定义、基本操作、中间操作、终端操作以及实际应用案例。
Java8新特性 Stream流详解
最新发布
qq_38196449的博客
01-03 1491
Stream流思想类似于工厂车间的流水线，Stream流不是一种数据结构，不保存数据，而是对数据进行加工处理。我们会发现这样又循环又创建新的集合再存进去，很麻烦Collections.addAll(nameList,"张无忌","周芷若","赵敏","说不得","张乐");//拿到所有姓张的放进zhangList中if(name.startsWith("张")){//遍历姓张的，拿出名字长度等于3的。
java8 新特性之stream用法
qq_34091758的博客
04-25 7004
//1. 得到集合中对象的某个属性的集合 list.stream().map(CheckRecord::getId).collect(Collectors.toList()); //2. 根据groupId分组, 得到map(key: groupId, value: 对应的list集合) Map<String, List<Stutent>> collectbyGroup...
Java 8 Stream 使用
赵彦军
05-27 446
转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/106197857 本文出自【赵彦军的博客】 目录1、基础概念filter 过滤findFirst 查找第一个sorted 从小到大排序map 方法用于映射每个元素到对应的结果limit 获取指定数量的流collect 将流转换成集合和聚合元素average 求平均值 1、基础概念 Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使.
Java8 Stream深度解析：从入门到实践
"Java8 Stream详解是一篇详细讨论JDK8新特性——Stream API的文档。文档涵盖了Stream的概念、特点、处理流程以及两种主要的操作符：中间操作符和终止操作符。通过实例演示了如何使用filter、distinct和limit等中间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

三木几

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

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

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

打赏作者

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

抵扣说明：

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

余额充值