Stream

最新推荐文章于 2023-06-10 12:29:21 发布
最新推荐文章于 2023-06-10 12:29:21 发布
阅读量180 收藏
点赞数
分类专栏： 笔记 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51707222/article/details/122526611
版权

什么是Stream?

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

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

简单案例:
苹果类

package com.ffyc.java8up.stream;

public class Apple {
    private Integer num;
    private String color;
    private String state;

    public Apple(Integer num, String color, String state) {
        this.num = num;
        this.color = color;
        this.state = state;
    }

    public Integer getNum() {
        return num;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "num=" + num +
                ", color='" + color + '\'' +
                ", state='" + state + '\'' +
                '}';
    }
}


public class Demo1 {
    public static void main(String[] args) {
        List<Apple> appleList = new ArrayList<>();
        appleList.add(new Apple(1, "red", "64G"));
        appleList.add(new Apple(2, "red", "64G"));
        appleList.add(new Apple(3, "green", "128G"));
        appleList.add(new Apple(4, "green", "128G"));
        appleList.add(new Apple(5, "yellow", "256G"));
        appleList.add(new Apple(6, "yellow", "256G"));

        /*
         * 我们的需求是在appleList中找到红色的苹果
         * 使用Stream快速操作*/
        List<Apple> list = appleList.stream()
                .filter(apple -> apple.getColor().equals("red"))
                .collect(Collectors.toList());
        System.out.println(list);
    }
}

输出结果
在这里插入图片描述

这就是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> stream2 = Stream.of(1, 2, 3, 4, 5, 6);
  • 使用BufferedReader.lines()方法,将每行内容转成流
 BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));
 Stream<String> stream3 = 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()将其映射成一个新元素

代码演示:
filter：过滤流中的某些元素

public class MiddleOperation {
    public static void main(String[] args) {
        //filter：过滤流中的某些元素,
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7).filter(e -> e > 4);
        integerStream.forEach(integer -> System.out.println(integer));
    }
}

在这里插入图片描述
sorted(): 自然排序，流中元素需实现 Comparable 接口

  • 从小到大
public class MiddleOperation {
    public static void main(String[] args) {
      
        Stream<Integer> integerStream = Stream.of(5, 3, 2, 4, 1, 9, 7,6)
                //从小到大排序
                    .sorted();
        integerStream.forEach(integer -> System.out.println(integer));
    }
}

在这里插入图片描述

  • 从大到小
public class MiddleOperation {
    public static void main(String[] args) {
      
        Stream<Integer> integerStream = Stream.of(5, 3, 2, 4, 1, 9, 7,6)
                //从大到小排序
                  .sorted((o1, o2) -> o2-o1);
        integerStream.forEach(integer -> System.out.println(integer));
    }
}

在这里插入图片描述
distinct: 去除重复元素

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

        Stream<Integer> integerStream = Stream.of(1, 1, 2, 2, 2, 3, 3,4)
                .distinct();
        integerStream.forEach(integer -> System.out.println(integer));
    }
}

在这里插入图片描述
limit(n): 获取 n 个元素

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

        Stream<Integer> integerStream = Stream.of(1, 1, 2, 2, 2, 3, 3,4)
        .limit(4);
        integerStream.forEach(integer -> System.out.println(integer));
    }
}

在这里插入图片描述
skip(n): 跳过 n 元素，配合 limit(n)可实现分

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

        Stream<Integer> integerStream = Stream.of(1, 1, 2, 2, 2, 3, 3,4)
                .skip(6);
        integerStream.forEach(integer -> System.out.println(integer));
    }
}

在这里插入图片描述

  • 分页
public class MiddleOperation {
    public static void main(String[] args) {

        Stream<Integer> integerStream = Stream.of(1, 1, 2, 2, 2, 3, 3,4)
               .skip(2)
                .limit(3);
        integerStream.forEach(integer -> System.out.println(integer));
    }
}

在这里插入图片描述
map(): 将其映射成一个新的元素
将某个值映射到stream中去

package com.ffyc.java8up.stream;

public class Apple {
    private Integer num;
    private String color;
    private String state;

    public Apple(Integer num, String color, String state) {
        this.num = num;
        this.color = color;
        this.state = state;
    }

    public Integer getNum() {
        return num;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "num=" + num +
                ", color='" + color + '\'' +
                ", state='" + state + '\'' +
                '}';
    }
}


public class Demo2 {
    public static void main(String[] args) {
        List<Apple> appleList = new ArrayList<>();
        appleList.add(new Apple(1, "red", "64G"));
        appleList.add(new Apple(2, "red", "64G"));
        appleList.add(new Apple(3, "green", "128G"));
        appleList.add(new Apple(4, "green", "128G"));
        appleList.add(new Apple(5, "yellow", "256G"));
        appleList.add(new Apple(6, "yellow", "256G"));

        /*
        中间操作map
        将某个值映射到stream中去
         */
        appleList.stream()
                .map(Apple::getColor)
                .forEach(integer -> System.out.println(integer));

    }
}

将苹果颜色映射到流中去
在这里插入图片描述

终端操作

forEach: 遍历流中的元素

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

        Stream<Integer> integerStream = Stream.of(1, 1, 2, 2, 2, 3, 3,4);
        integerStream.forEach(integer -> System.out.println(integer));
    }
}

在这里插入图片描述
toArray:将流中的元素倒入一个数组

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

     Stream<Integer> integerStream = Stream.of(1, 1, 2, 2, 2, 3, 3,4);
        Object[] objects = integerStream.toArray();
        System.out.println(Arrays.toString(objects));
    }
}

在这里插入图片描述
max:返回流中元素最大值

public class MiddleOperation {
    public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(1, 3, 1, 4, 5, 2, 1);
        Integer max = integerStream.max((o1, o2) -> o1 - o2).get();
        System.out.println(max);
    }
}

在这里插入图片描述
Min:返回流中元素最小值

public class MiddleOperation {
    public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(1, 3, 1, 4, 5, 2, 1);
        Integer min = integerStream.min((o1, o2) -> o1 - o2).get();
        System.out.println(min);
	}
}

在这里插入图片描述

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

public class MiddleOperation {
    public static void main(String[] args) {
      
        Stream<Integer> integerStream = Stream.of(1, 3, 1, 4, 5, 2, 1);
        long count = integerStream.count();
        System.out.println(count);
    }
}

在这里插入图片描述
Reduce:所有元素求和

public class MiddleOperation {
    public static void main(String[] args) {
       Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
        Integer integer = integerStream.reduce((o1, o2) -> o1 + o2).get();
        System.out.println(integer);
    }
}

在这里插入图片描述

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

public class MiddleOperation {
    public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
        boolean anyMatch = integerStream.anyMatch(integer -> integer == 5);
        System.out.println(anyMatch);
    }
}

在这里插入图片描述
allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返
回 true，否则返回 fals

public class MiddleOperation {
    public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
        boolean allMatch = integerStream.allMatch(integer -> integer == 5);
        System.out.println(allMatch);
    }
}

在这里插入图片描述
findFirst：返回流中第一个元素

public class MiddleOperation {
    public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(5, 3, 2, 4, 1, 9, 7,6);
        System.out.println(integerStream.findFirst().get());

    }
}

在这里插入图片描述
collect:将流中的元素倒入一个集合,Collection 或 Map

  • tolist
package com.ffyc.java8up.stream;

public class Apple {
    private Integer num;
    private String color;
    private String state;

    public Apple(Integer num, String color, String state) {
        this.num = num;
        this.color = color;
        this.state = state;
    }

    public Integer getNum() {
        return num;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "num=" + num +
                ", color='" + color + '\'' +
                ", state='" + state + '\'' +
                '}';
    }
}


public class Demo2 {
    public static void main(String[] args) {
        List<Apple> appleList = new ArrayList<>();
        appleList.add(new Apple(1, "red", "64G"));
        appleList.add(new Apple(2, "red", "64G"));
        appleList.add(new Apple(3, "green", "128G"));
        appleList.add(new Apple(4, "green", "128G"));
        appleList.add(new Apple(5, "yellow", "256G"));
        appleList.add(new Apple(6, "yellow", "256G"));

        List<Apple> collect = appleList.stream()
                .sorted(((o1, o2) -> o2.getNum()-o1.getNum()))
                .collect(Collectors.toList());
        System.out.println(collect);

    }
}

在这里插入图片描述

  • toSet
public class Demo2 {
    public static void main(String[] args) {
        List<Apple> appleList = new ArrayList<>();
        appleList.add(new Apple(1, "red", "64G"));
        appleList.add(new Apple(2, "red", "64G"));
        appleList.add(new Apple(3, "green", "128G"));
        appleList.add(new Apple(4, "green", "128G"));
        appleList.add(new Apple(5, "yellow", "256G"));
        appleList.add(new Apple(6, "yellow", "256G"));

     Set<Apple> collect = appleList.stream()
        .collect(Collectors.toSet());
        System.out.println(collect);

    }
}

在这里插入图片描述

  • toMap
public class Demo2 {
    public static void main(String[] args) {
        List<Apple> appleList = new ArrayList<>();
        appleList.add(new Apple(1, "red", "64G"));
        appleList.add(new Apple(2, "red", "64G"));
        appleList.add(new Apple(3, "green", "128G"));
        appleList.add(new Apple(4, "green", "128G"));
        appleList.add(new Apple(5, "yellow", "256G"));
        appleList.add(new Apple(6, "yellow", "256G"));

   Map<Integer, String> collect = appleList.stream().
                collect(Collectors.toMap(Apple::getNum, Apple::getColor));
        System.out.println(collect);

    }
}

在这里插入图片描述

PG.杨帅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pgstream:Go的日志流库
05-11
PG流 PGStream是一个Go包，它实现了posgres和支持的接口。 这使您可以传递可以在进程之间共享的io.Reader或io.Writer 。 用法 首先，使用以下架构创建一个表： CREATE TABLE logs ( id SERIAL , stream text not null , text text ); CREATE INDEX index_stream_on_logs ON logs USING btree (stream); 然后初始化一个新的pgstream引擎： rw := pgstream . New ( "mylogs" , db ) io . WriteString ( rw , "Log line" ) io . Copy ( os . Stdout , rw )
Elecard StreamEye
08-13
Elecard StreamEye是一款专业的视频编码和流媒体分析工具，它主要针对广播级和网络级的音视频内容进行质量检查和故障检测。这款软件能够帮助用户在传输或制作过程中发现潜在的问题，确保视频质量和合规性，从而提升...
Postgresql Stream 配置
weixin_33883178的博客
12-23 183
一、安装配置数据库（master\slave）系统信息：192.168.1.20gserver20(master)192.168.1.21gserver21(slave)1.建立目录mkdir/opt/pgsql-9.3.1mkdir/opt/pgdata/mainmkdir/opt/pgdata/archive2.建立postgres用户adduserpostg...
Postgresql stream复制高可用集群搭建——筑梦之路
筑梦之路
05-14 472
规划： 复制技术：PostgreSQL Stream 主从架构：一主两从 数据库版本：13.6 操作系统：Centos 7.9 192.168.50.10 Centos 7 13.6 主 软件+DB 192.168.50.11 Centos 7 13.6 从 软件 192.168.50.12 Centos 7 13.6 从 软件 部署流程为： 1、在三个节点分别安装PG软件； 2、在作为主节点的节点上初始化数据库； 3、修改postgresql.conf，pg_hba.conf配置文件； 4、.
postgresql stream 模式搭建
weixin_33797791的博客
06-16 110
PostgreSQL hot standby就是实现多个PostgreSQL节点实现数据同步(其实9.0x不只是异步)、这个同步是针对整数集群的(包含一切的数据、 DDL,DCL都会在salve上同步)。salve在利用日志恢复数据同时也能提供只读的操作，这样就可以利用这个技术实现多台主机数据同步和读取操作 的负载平衡。另存还有一点跟8.x不一样的地方就是这次9.0...
Postgresql - PipelineDB - Stream
chuckchen1222的博客
11-25 489
  Stream 是允许客户机通过Continuous Views推送时间序列数据的抽象。stream row，或者简单的事件，看起来完全像普通的表行，并且用于将数据写入流的接口与用于将数据写入表的接口相同。然而，stream 的语义与表基本上不同。 也就是说，事件仅在 stream 中“存在”，直到它们被从该 stream 读取的所有Continuous Views消费为止。即使如此，用户仍...
Java--Stream流详解
MinggeQingchun的博客
08-30 7万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合
热门推荐
云深不知处
11-09 26万+
Java8 Stream横空出世，让我们从繁琐冗长的迭代中解脱出来，集合数据操作变得优雅简洁。 这些操作：集合的filter（筛选）、归约（reduce）、映射（map）、收集（collect）、统计（max、min、avg）等等，一行代码即可搞定！ 让我们一起敲打案例代码，搞定Java8 stream吧！
Java Stream流详解
最新发布
唯有努力，方可自信！
06-10 2万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
Stream详解
qq_42449963的博客
10-28 6594
一、简介      java8新添加了一个特性：流Stream。Stream让开发者能够以一种声明的方式处理数据源（集合、数组等），它专注于对数据源进行各种高效的聚合操作（aggregate operation）和大批量数据操作 (bulk data operation)。      Stream API将处理的数据源看做一种Stream（流），Stream（流）在Pipeline（管道）中传输和运算，支持的运算包含筛选、排序、
pgdeltastream：流式传输Postgres逻辑复制至少一次通过WebSocket进行更改
02-05
PGD​​eltaStream 使用Postgres的逻辑解码功能，Golang网络服务器至少一次通过websocket流式传输Postgres更改。 注意：当前，pgdeltastream是理想的Golang服务器样板，它是如何连接到Postgres逻辑复制插槽，拍摄快照和流更改的参考样板。 它不应用于将websocket公开给任意客户端！ 介绍 PGD​​eltaStream使用Postgres的逻辑解码功能通过websocket连接流式传输表更改。 它是一种无状态服务，可以直接连接到Postgres实例。 PGD​​eltaStream使您可以通过端点对当前数据进行快照，然后在快照
streamsets-帮助手册-.pdf
06-09
StreamSets 帮助手册 StreamSets 是一个数据integration平台，用于处理和处理大规模数据流。以下是根据 StreamSets 帮助手册生成的知识点： Pipeline 概念和设计 Pipeline 是 StreamSets 的核心概念，用于描述...
java stream
12-02
java stream doc.
streamsets.tgz
08-20
StreamSets 是一个强大的数据集成平台，专为现代大数据架构设计，提供数据流管理和处理功能。其Data Collector是该平台的核心组件，允许用户构建、运行和监控数据管道，将数据从各种源传输到不同的目标。标题提到的 ...
配置PostgreSQL数据库流复制（replication stream）环境
闫不由衷的专栏
03-03 2537
原文地址 http://www.sijitao.net/1764.html 在配置之前准备两台服务器环境。 第一步：在两个环境中分别安装postgresql数据库 推荐使用源码编译安装，安装步骤可以参考之前写的文章“通过源码编译安装PostgreSQL步骤及问题总结”，网址：http://www.sijitao.net/1535.html 。备库可以不做初始化数据的操作。
Postgresql - PipelineDB - 初识Stream功能 - 流式计算
chuckchen1222的博客
11-04 1480
PipelineDB ， 有一个很好用的流式计算功能。将想要得到的结果逻辑，存储为表的雾化视图。 在插入数据的时候不会存储数据本身，是在每次插入或改变的时候按照当初建好的VIEW的逻辑存储数据，所以需要存储的数据很少。   实验： Cent OS 7 + PG 10.5 + PipelineDB 1.0.0-4   建表 mytest=# CREATE FOREIGN TABLE ...
streamEye绿色版本
07-01
streamEye是一款专为音视频分析设计的工具，尤其在处理H264编码格式的视频时表现出色。这款工具在Windows平台上提供了免费的绿色版本，无需安装，下载解压后即可使用，方便快捷。streamEye的主要功能是帮助用户深入...
Linux内存性能测试工具stream
07-27
"Linux内存性能测试工具stream"是一个专门用于评估计算机内存（RAM）性能的工具。本文将深入探讨STREAM的作用、工作原理以及如何在Linux环境中使用它。 STREAM，全称是“Simple Triad Memory Benchmark”，是由John...
stream
05-27
stream()是Java 8中新增的一个方法，它可以将集合转化为一个流（Stream）。流是一种数据处理的方式，它可以通过一系列的中间操作来对数据进行处理，最终生成想要的结果。使用流式处理可以简化代码，提高代码的可读性和可维护性。 例如，我们有一个List<String>，我们可以通过以下方式将它转化为一个流并进行处理： ``` List<String> list = Arrays.asList("apple", "banana", "orange"); list.stream() .filter(s -> s.startsWith("a")) .map(String::toUpperCase) .sorted() .forEach(System.out::println); ``` 上述代码将list转化为一个流，然后对流进行过滤、映射、排序和输出操作。最终输出结果为： ``` APPLE ``` 注意：stream()方法只能用于集合类，不能用于数组。如果要对数组进行处理，需要使用Arrays.stream()方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值