重学java 77.JDK新特性 ③ Stream流

news2024/11/23 1:52:12

The road is long,it can be really hard.Whatever you do,you hold on to that foolishly hopeful smile

                                                                                                                        —— 24.6.19

Stream流

        stream流中的"流"不是特指"IO流",它是一种"流式编程"(编程方式),可以看做是"流水线

package S109Stream;

import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo312Stream {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("张三丰");
        list.add("张大彪");
        list.add("吕不韦");
        list.add("张三");
        list.add("赵姬");
        list.add("张翠山");
        list.add("缪毒");

        /*
        方式1：
        // 需求1：要筛选出姓张的人
        ArrayList<String> listZhang = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                listZhang.add(s);
            }
        }
        System.out.println(listZhang);

        // 需求2：筛选出姓张、姓名三个字的人
        ArrayList<String> listThrZhang = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")&&s.length()==3){
                listThrZhang.add(s);
            }
        }
        System.out.println(listThrZhang);

        // 需求3：遍历集合，将三个字姓张的打印出来
        for (String s : listThrZhang) {
            System.out.println(s);
        }
         */

        // 方式2：将list转成stream流对象
        Stream<String> stream = list.stream();
        /*
                stream.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张");
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()==3;
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
         */

        // 方式3：将list转成stream流对象，并用lambda表达式输出
        System.out.println("——————————————Lambda表达式——————————————");
        stream.filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
    }
}

1.Stream的获取

① 针对集合：Collection中的方法

        Stream<E> stream()

② 针对数组：Stream接口中的静态方法

        Static <T> Stream<T> of(T...values)

import java.util.ArrayList;
import java.util.stream.Stream;

public class Demo313StreamGet {
    public static void main(String[] args) {
        // ① 针对集合：Collection中的方法
        //     Stream<E> stream()
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        Stream<String> stream = list.stream();
        System.out.println(stream);     // 地址值：java.util.stream.ReferencePipeline$Head@7f31245a

        // ② 针对数组：Stream接口中的静态方法
        //     Static <T> Stream<T> of(T...values)
        Stream<String> stream1 = Stream.of("张三","李四","王五");
        System.out.println(stream1);    // java.util.stream.ReferencePipeline$Head@6d6f6e28
    }
}

2.Stream中的方法

① forEach方法：

        void forEach(Consumer<? super T> action);

注意：forEach是一个终结方法（运行结束会自动关闭流）

import java.util.function.Consumer;
import java.util.stream.Stream;

public class Demo314StreamForeach {
    public static void main(String[] args) {
        foreach();
    }

    /**
     *  逐一处理，可以用来遍历
     */

    private static void foreach() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五");
//        stream1.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        System.out.println("—————————————Lambda表达式—————————————");
        stream1.forEach(s -> System.out.println(s));
    }
}

     

② long count()方法

1.作用：统计元素个数

2.注意：count也是一个终结方法

import java.util.stream.Stream;

public class Demo315StreamCount {
    public static void main(String[] args) {
        count();
    }

    /**
     * 统计元素个数
     */
    private static void count() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六");
        long count = stream1.count();
        System.out.println(count);

    }
}

③ Stream<T> filter(Predicate<? super T>predicate)方法

1.方法：stream<T> filter(Predicate<? super T> predicate)方法,返回一个新的stream流对象

2.作用：根据某个条件进行元素过滤

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo316StreamFilter {
    public static void main(String[] args) {
        filter();
        filter2();
    }

    private static void filter2() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六","马七","张晓梅","马冬梅");
        System.out.println("——————————————————lembda表达式————————————————");
        stream1.filter(s -> s.length() == 3).forEach(s -> System.out.println(s));

    }

    private static void filter() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六","马七","张晓梅","马冬梅");
        Stream<String> newStream = stream1.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 3;
            }
        });

        newStream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
    }
}

④ Stream<T> limit(long maxsize)方法

        获取Stream流对象中的前n个元素，返回一个新的Stream流对象

import java.util.stream.Stream;

public class Demo317StreamLimit {
    public static void main(String[] args) {
        limit();
    }

    /**
     * 获取前几个元素
     */
    private static void limit() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六","马七","张晓梅","马冬梅");
        stream1.limit(3).forEach(s-> System.out.println(s));
    }
}

⑤ Stream<T> skip(long n)

        跳过stream流对象中的前n个元素,返回一个新的Stream流对象

import java.util.stream.Stream;

public class Demo318StreamSkip {
    public static void main(String[] args) {
        skip();
    }

    /**
     * 跳过前n个元素
     */
    private static void skip() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六","马七","张晓梅","马冬梅");
        stream1.skip(2).forEach(s-> System.out.print(s+" "));
    }
}


⑥ static<T> Stream<T> concat(Stream<? extends T> a, Stream<?extends T> b)

        两个流合成一个流

import java.util.stream.Stream;

public class Demo319StreamConcat {
    public static void main(String[] args) {
        Concat();
    }

    /**
     * 流合并，是一个静态方法
     */
    private static void Concat() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五");
        Stream<String> stream2 = Stream.of("赵六","马七","张晓梅","马冬梅");
        Stream<String> stream3 = Stream.concat(stream1, stream2);
        
        stream3.forEach(s -> System.out.print(s+" "));
    }
}

⑦ 将Stream流变成集合

        从stream流对象转成集合对象，使用stream接口方法collect()

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo320StreamCollect {
    public static void main(String[] args) {
        Collect();
        Collect1();
    }

    /**
     * 流转集合
     */
    private static void Collect1() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六","马七","张晓梅","马冬梅");
        List<String> collect1 = stream1.collect(Collectors.toList());
        System.out.println(collect1);
    }
    
    private static void Collect() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六","马七","张晓梅","马冬梅");
        Set<String> collect = stream1.collect(Collectors.toSet());
        System.out.println(collect);
    }
}

⑧ distinct方法

Stream<T> distinct()

元素去重复，依赖hashcode和equals方法

Person类

import java.util.Objects;

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    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;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

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

import java.util.stream.Stream;

public class Demo321StreamDistinct {
    public static void main(String[] args) {
        distinct();
    }

    /**
     * 去重复元素的
     * 被去重的元素底层需要重写hashcode和equals方法
     */
    private static void distinct() {
        Stream<String> stream1 = Stream.of("张三", "李四", "王五", "张三","张晓梅","赵六","马七","张晓梅","马冬梅");
        stream1.distinct().forEach(s->System.out.print(s+" "));
        System.out.println();
        Stream<Person> stream2 = Stream.of(new Person("张三",10),new Person("李四",12),new Person("张三",10));
        stream2.distinct().forEach(person->System.out.print(person+" "));

    }
}

⑨ 转换流中的类型

Stream<R> map(Function<T,R> mapper) —> 转换流中的数据类型

import java.util.function.Function;
import java.util.stream.Stream;

public class Demo322StreamMap {
    public static void main(String[] args) {
        map();
    }

    /**
     * 转换流中的类型
     */
    private static void map() {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        stream.map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return integer.toString();
            }
        }).forEach(s -> System.out.println(s+1));
    }
}

⑩ Stream流练习

1.第一个队伍只要名字为3个字的成员姓名;——filter
2.第一个队伍筛选之后只要前3个人;——limit
3.第二个队伍只要姓张的成员姓名;——filter
4.第二个队伍筛选之后不要前2个人;——skip
5.将两个队伍合并为一个队伍;——concat
6.打印整个队伍的姓名信息。——forEach

import java.util.ArrayList;
import java.util.stream.Stream;

public class Demo323StreamPractice {
    public static void main(String[] args) {
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("老于");
        one.add("庄于");
        one.add("孙子");
        one.add("洪七公");

        ArrayList<String> two =new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("张三丰");
        two.add("赵丽颖");
        two.add("张二狗");
        two.add("张天爱");
        two.add("张三");

        // 将两个集合变成Stream流
        Stream<String> teamA = one.stream();
        Stream<String> teamB = two.stream();
        /**
         * 1.第一个队伍只要名字为3个字的成员姓名;——filter
         * 2.第一个队伍筛选之后只要前3个人;——limit
         * 3.第二个队伍只要姓张的成员姓名;——filter
         * 4.第二个队伍筛选之后不要前2个人;——skip
         * 5.将两个队伍合并为一个队伍;——concat
         * 6.打印整个队伍的姓名信息。——forEach
         */

        Stream<String> listA = teamA.filter(s -> s.length() == 3).limit(3);
        Stream<String> listB = teamB.filter(s -> s.startsWith("张")).skip(2);
        Stream.concat(listA, listB).forEach(s -> System.out.println(s));
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1841219.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

在 Visual Studio 2022 (Visual C++ 17) 中使用 Visual Leak Detector

在 Visual Studio 2022 (Visual C++ 17) 中使用 Visual Leak Detector

在 Visual C 2022 中使用 Visual Leak Detector 1 问题描述1.1 内存泄漏的困扰和解决之道1.2 内存泄漏检测工具的选择1.3 VLD的现状 2 安装和设置VLD的环境变量2.1 安装VLD文件2.2 VLD安装后的目录和文件说明2.2.1 include子目录说明2.2.2 lib子目录说明2.2.2.1 目录整理 2.2.3…
阅读更多...
【全文档】软件项目经理需要掌握的文档有哪些？

【全文档】软件项目经理需要掌握的文档有哪些？

软件项目经理在项目管理过程中需要编写多种文档&#xff0c;以下是常见的十五个文档&#xff1a; 项目计划&#xff1a; 详细描述了项目的范围、时间、成本、资源、沟通计划等关键信息&#xff0c;是项目管理的核心文档。 需求文档&#xff1a; 记录了项目的业务需求、功能需求…
阅读更多...
VMR，支持30+种编程语言的SDK版本管理器，支持Windows/MacOS/Linux。

VMR，支持30+种编程语言的SDK版本管理器，支持Windows/MacOS/Linux。

官方文档地址&#xff1a;documents 官方项目地址&#xff1a;github 欢迎安装使用&#xff0c;分享转发&#xff0c;前往github star。 跨平台&#xff0c;支持Windows&#xff0c;Linux&#xff0c;MacOS支持多种语言和工具&#xff0c;省心受到lazygit的启发&#xff0c;拥…
阅读更多...
【stm32-新建工程-CubeMX】

【stm32-新建工程-CubeMX】

stm32-新建工程-CubeMX ■ CubeMX 生产工程 ■ CubeMX 生产工程
阅读更多...
数据库 |试卷八试卷九试卷十

数据库 |试卷八试卷九试卷十

1.基数是指元组的个数 2.游标机制 3.触发器自动调用 4.count(*)统计所有行&#xff0c;不忽略空值null&#xff0c;但不但要全局扫描&#xff0c;也要对表的每个字段进行扫描&#xff1b; 5.eacherNO INT NOT NULL UNIQUE&#xff0c;为什么不能断定TeacherNO是主码&#xff…
阅读更多...
JAVAEE之网络原理（2）_传输控制协议(TCP)的连接管理机制，三次握手、四次挥手，及常见面试题

JAVAEE之网络原理（2）_传输控制协议(TCP)的连接管理机制，三次握手、四次挥手，及常见面试题

前言 在上一节中&#xff0c;我们简单介绍了 TCP 协议的相关概念和格式&#xff0c;而且还介绍了TCP 协议原理中的 确认应答机制、超时重传机制&#xff0c;在本节中我们将会继续介绍 TCP协议原理中的其他机制。 连接管理机制&#xff08;安全机制&#xff09; 在正常情况下&…
阅读更多...
数学建模基础：统计模型

数学建模基础：统计模型

目录 前言 一、概率与统计基础 二、统计模型 三、Matlab统计工具箱 四、实例示范&#xff1a;市场调查分析 步骤 1&#xff1a;数据导入 步骤 2&#xff1a;数据可视化 步骤 3&#xff1a;建立多元线性回归模型 步骤 4&#xff1a;模型验证 步骤 5&#xff1a;模型应…
阅读更多...
Java学习 （二）关键字、标识符、数组

Java学习 （二）关键字、标识符、数组

一、关键字 我们第一章案例中有很多关键字&#xff0c;比如class、public、static、void等&#xff0c;这些关键字依旧被java定义好了&#xff0c;可以拿来用&#xff0c;不需要死记硬背&#xff0c;按照官方文档查询即可 #官方文档 https://docs.oracle.com/javase/tutorial/j…
阅读更多...
高速公路收费图片分析系统深入理解

高速公路收费图片分析系统深入理解

当今社会&#xff0c;随着交通运输业的快速发展&#xff0c;高速公路已成为人们出行的重要选择。而高速公路收费系统作为保障道路可持续运营的重要组成部分&#xff0c;其效率和准确性对于保障道路畅通和交通安全至关重要。近年来&#xff0c;随着技术的不断进步&#xff0c;高…
阅读更多...
elasticsearch的安装和配置

elasticsearch的安装和配置

单节点安装与部署 我们通过docker进行安装 1.docker的安装 如果以及安装了docker就可以跳过这个步骤。 首先更新yum: yum update安装docker: yum install docker查看docker的版本&#xff1a; docker -v此时我们的docker就安装成功了。 2.创建网络 我们还需要部署kiban…
阅读更多...
【VMware】VMware虚拟机安装_配置_使用教程

【VMware】VMware虚拟机安装_配置_使用教程

一、准备工作 1、下载VMware软件&#xff1a;访问VMware官方网站&#xff0c;下载适合你操作系统的VMware Workstation Pro安装包。 下载地址&#xff1a;VMware Desktop Hypervisors for Windows, Linux, and Mac 2、准备操作系统镜像文件&#xff1a;根据你想要在虚拟机中安…
阅读更多...
读AI新生：破解人机共存密码笔记06人工智能生态系统

读AI新生：破解人机共存密码笔记06人工智能生态系统

1. 深蓝 1.1. “深蓝”的胜利虽然令人印象深刻&#xff0c;但它只是延续了几十年来显而易见的趋势 1.2. 国际象棋算法的基本设计是由克劳德香农在1950年提出的 1.2.1. 这一基本设计在20世纪60年代初实现了重大改进 1.2.2. 最优秀的国际象棋程序的等级评分稳步提高&#xff…
阅读更多...
数据分析第十二讲 数据可视化入门（一）

数据分析第十二讲 数据可视化入门（一）

数据可视化入门&#xff08;一&#xff09; 在完成了对数据的透视之后&#xff0c;我们可以将数据透视的结果通过可视化的方式呈现出来&#xff0c;简单的说&#xff0c;就是将数据变成漂亮的统计图表&#xff0c;因为人类对颜色和形状会更加敏感&#xff0c;然后再进一步解读…
阅读更多...
ChinaTravel成流量密码，景区如何打造视频监控管理平台提升旅游体验

ChinaTravel成流量密码，景区如何打造视频监控管理平台提升旅游体验

随着中国经济的飞速发展和人民生活水平的持续提高&#xff0c;旅游已经成为越来越多人休闲放松的首选方式。近期&#xff0c;随着互联网的普及和社交媒体的兴起&#xff0c;以及免签政策带火入境游&#xff0c;“ChinaTravel”已成为社交网络上的一大流量密码&#xff0c;吸引了…
阅读更多...
数学建模基础：非线性模型

数学建模基础：非线性模型

目录 前言 一、非线性方程组 二、非线性规划 三、微分方程模型 四、非线性模型的应用 五、实例示范&#xff1a;传染病传播模型 实例总结 五、总结 前言 非线性模型用于描述变量之间的非线性关系&#xff0c;相比线性模型&#xff0c;其数学形式更为复杂&#xff0c;但…
阅读更多...
操作系统真象还原：输入输出系统

操作系统真象还原：输入输出系统

第10章-输入输出系统 这是一个网站有所有小节的代码实现&#xff0c;同时也包含了Bochs等文件 10.1 同步机制–锁 10.1.1 排查GP异常&#xff0c;理解原子操作 线程调度工作的核心内容就是线程的上下文保护&#xff0b;上下文恢复 。 根本原因是访问公共资源需要多个操作&…
阅读更多...
[Linux] 版本控制

[Linux] 版本控制

git是一个开源的分布式版本控制系统 早期&#xff0c;每做一个就备份一下 后来&#xff0c;自动保存 一个软件多人开发
阅读更多...
YOLOv10改进 | 注意力篇 | YOLOv10引入EMAttention(EMA）注意力

YOLOv10改进 | 注意力篇 | YOLOv10引入EMAttention(EMA）注意力

1. EMA介绍 1.1 摘要：在各种计算机视觉任务中说明了通道或空间注意机制在产生更可辨别的特征表示方面的显着有效性。 然而，通过通道降维来建模跨通道关系可能会给提取深度视觉表示带来副作用。 本文提出了一种新型高效的多尺度注意力（EMA）模块。 着眼于保留每个通道的信息…
阅读更多...
《Windows API每日一练》5.1 键盘基础

《Windows API每日一练》5.1 键盘基础

本节我们讲述关于键盘的一些基础知识。当我们按下一个键盘按键时&#xff0c;会产生一个键盘按键消息。这一点你能确定吗&#xff1f;假如是一个菜单快捷键消息&#xff0c;或者是一个子窗口控件消息呢&#xff1f;这就超出了本节讨论的范围&#xff0c;我们将在菜单和子窗口控…
阅读更多...
零编程数据可视化展示：十个简易案例！

零编程数据可视化展示：十个简易案例！

数据可视化是呈现数据内在价值的最终手段。数据可视化实例利用各种图表和图形设计手段&#xff0c;合乎逻辑地展示复杂而不直观的数据。为了让用户直观清楚地了解他们想要的数据及其比较关系&#xff0c;数据可视化实例的呈现至关重要。即时设计整理了10个数据可视化实例&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023