Java研学-Stream

最新推荐文章于 2024-08-31 10:53:27 发布
最新推荐文章于 2024-08-31 10:53:27 发布
阅读量584 收藏 11
点赞数 17
分类专栏： # Java研学 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhlyxx/article/details/134861022
版权

一 Stream

1 概述

  JDK8的特性之一，并不是传统意义上的IO流，而是一个用于数据传输的"管道"，他的作用是提供一组高效的操作数据的方法 – 针对集合中的数据

2 应用Stream对象

通常筛选集合中元素的方法

public class Play {
    public static void main(String[] args) {
        // 定义集合存放元素
        List<String> names= Arrays.asList("大黄","大白","小小黑");
        findNameLength(names);
        findNameByBig(names);
    }
    // 获取名字长度大于2的且名字中含有小字的动物
    private static void findNameLength(List<String> names){
        // 创建存放所有名字的集合
        List<String> n=new ArrayList<>();
        // 遍历筛选
        for (String s:names) {
            if(s.length()>2){
                n.add(s);
            }
        }
        // 筛选名字中有小的
        List<String> l=new ArrayList<>();
        for (String s:n) {
            if(s.contains("小")){
                l.add(s);
            }
        }
        System.out.println(l);
    }
    // 显示以大开头的动物
    private static void findNameByBig(List<String> names){
        List<String> n=new ArrayList<>();
        for (String s:names) {
            if(s.startsWith("大")){
                n.add(s);
            }
        }
        System.out.println(n);
    }
}

当过滤条件过多时，可使用Stream对象提供的方法,简化操作

public class Play {
    public static void main(String[] args) {
        // 定义集合存放元素
        List<String> names= Arrays.asList("大黄","大白","小小黑");
        findNameLength(names);
        findNameByBig(names);
    }
    // 获取名字长度大于2的且名字中含有小字的动物
    private static void findNameLength(List<String> names){
        names.stream()
                .filter(s->s.contains("小"))
                .filter(s->s.length()>2)
                .forEach(System.out::println);
    }
    // 显示以大开头的动物
    private static void findNameByBig(List<String> names){
        // 将集合转为Stream  集合类提供
        // public Stream<T> stream()
        // Stream<String> stream = names.stream();
        // 通过Stream对象调用过滤方法,此方法会遍历集合中的元素
        // public Stream<T> filter(Predocate<T> pre)
        //Stream<String> n = stream.filter(new Predicate<String>() {
        // @Override
        // public boolean test(String s) {
        //     return s.startsWith("大");
        // }
        // });
        // 通过Stream对象调用方法展示数据
        // n.forEach(System.out::println);
        names.stream()
                .filter(s -> s.startsWith("大"))
                .forEach(System.out::println);
    }
}

3 操作步骤

  核心点:将集合对象转换成Stream对象

  ① 转换成Stream对象

  ② 根据需求,调用Stream对象中的方法完成操作

  ③ 展示数据

  操作指定元素序列(集合或数组,集合居多)中符合指定要求(根据需求通过Stream对象调用方法完成对元素操作)的元素(集合或者数组中的数据)的一种技术

二 创建Stream对象的方式

1 共有五种

// 有限流
Collection默认的stream()方法和paralleStream()方法
Arrays.stream()
Stream.of()
// 无限流
Stream.iterate()
Stream.generate()

2 例子

public class Play {
    public static void main(String[] args) {
        // 方式1：单列集合转Stream
        // stream() 按集合中的顺序操作
        // paralleStream() 随机顺序进行操作
        List<String> list= Arrays.asList("大黄","大白","小黑");
        list.stream().forEach(System.out::println);
        list.parallelStream().forEach(System.out::println);
        // 方式2：数组转Stream
        Arrays.stream(new int[]{-2,-1,0,8,42}).forEach(System.out::println);
        // 方式3：将任意类型的多个数据视为一个整体转换为Stream
        Stream.of(false,10L,8,3.14,'@',"dwd").forEach(System.out::println);
        // 方式4：无限流 seed从指定数字计步 uo计步规则 配合limit(long size)可限定数据个数
        // Stream.iterate(T need,UnaryOperator<T> uo)
        /*Stream.iterate(1, new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer+3;
            }
        }).limit(3).forEach(System.out::println);*/
        Stream.iterate(1,i -> i+3).limit(3).forEach(System.out::println);
        // 方式5：无限连续的无序流 与limit搭配使用
        /*Stream.generate(new Supplier<Integer>() {
            @Override
            public Integer get() {
                return (int)(Math.random()*10+1);
            }
        }).limit(5).forEach(System.out::println);*/
        Stream.generate(()->(int)(Math.random()*10+1)).limit(3).forEach(System.out::println);
    }
}

三 Stream常用API

1 筛选与切片

public class PlayTest {
    // 筛选与切片
    @Test
    public void playFilter(){
        // 对集合中的元素进行过滤
        List<Integer> list= Arrays.asList(-2,4,0,4,12,85);
        list.stream()
                //显示所有偶数  -2 4 0 4 12
                .filter(i->i%2==0)
                // 去除重复元素 -2 4 0 12
                .distinct()
                // 保留指定个数 -2 4 0
                .limit(3)
                // 跳过几个元素 4 0
                .skip(1)
                .forEach(System.out::print);
    }
}

2 映射

public class PlayTest {
    @Test
    public void playMap(){
        // 字符串转小写
        List<String> s=Arrays.asList("daw","swfgeWEFA","AG");
        /*s.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toLowerCase();
            }
        }).forEach(System.out::println);*/
        // s.stream().map(s1->s1.toLowerCase()).forEach(System.out::println);
        s.stream().map(String::toLowerCase).forEach(System.out::println);
    }
    @Test
    public void playFlatMap(){
        // 两集合做一个Stream对象(取并集)  stream.of
        List<Integer> l1=Arrays.asList(1,2,3);
        List<Integer> l2=Arrays.asList(3,4,5);
        /*Stream.of(l1,l2).flatMap(new Function<List<Integer>, Stream<?>>() {
            @Override
            public Stream<?> apply(List<Integer> integers) {
                return integers.stream();
            }
        }).forEach(System.out::println);
        Stream.of(l1,l2).flatMap(i->i.stream()).forEach(System.out::println);*/
        Stream.of(l1,l2).flatMap(List::stream).forEach(System.out::println);
    }
}

3 排序

public class PlayTest {
    @Test
    public void playSort(){
        // 对集合中的元素排序  默认升序  泛型为数值
        List<Integer> list= Arrays.asList(-2,4,0,4,12,85);
        // 升序
        list.stream().sorted().forEach(System.out::println);
        // 降序
        list.stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        }).forEach(System.out::println);
        list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);
    }
}

4 查找匹配

public class PlayTest {
    @Test
    public void playMatch(){
        List<Integer> list= Arrays.asList(-2,4,0,4,12,85);
        // 查询是否所有元素都大于0
        boolean f1=list.stream().allMatch(i->i>0);
        System.out.println(f1);
        // 查询是否有个别元素小于0
        boolean f2=list.stream().anyMatch(i->i<0);
        System.out.println(f2);
        // 查询是否真的没有匹配到0
        boolean f3=list.stream().noneMatch(i->i==0);
        System.out.println(f3);
        // 返回集合中第一个元素
        Optional<Integer> f4=list.stream().findFirst();
        if(f4.isPresent()){
            System.out.println(f4.get());
        }
        // 返回集合中热任一元素
        Optional<Integer> any = list.stream().findAny();
        if(any.isPresent()){
            System.out.println(any.get());
        }
    }
}

5 统计

public class PlayTest {
	@Test
    public void playCount(){
        List<Integer> list= Arrays.asList(-2,4,0,4,12,85);
        // 集合数据的元素总个数
        long count = list.stream().count();
        System.out.println(count);
        // 查询集合元素的最大值
        Optional<Integer> max=list.stream().max(Comparator.comparingInt(i->i));
        if(max.isPresent()){
            System.out.println(max.get());
        }
        // 查询有最小值
        Optional<Integer> min=list.stream().min(Comparator.comparingInt(i->i));
        if(min.isPresent()){
            System.out.println(min.get());
        }
    }
}

6 汇总

public class PlayTest {
	@Test
    public void playCollect(){
        // Stream转集合
        // 转list
        List<Object> l1=Stream.of(5,456,-5,3.14).collect(Collectors.toList());
        System.out.println(l1);
        // 转set
        List<Integer> l2=Arrays.asList(-2,4,0,4,12,85);
        Set<Integer> set = l2.stream().collect(Collectors.toSet());
        System.out.println(set);
        // 转TreeSet
        TreeSet<Integer> treeSet = l2.stream().collect(Collectors.toCollection(TreeSet::new));
        System.out.println(treeSet);
        // 转map 目前Stream是单列 map为双列 故转为map后key同时也是value
        // key不能重复 转换前先去重 两种方式去重 转set集合 或用Stream中的distinct()方法
/*        Map<Integer,Integer> map=l2.stream().distinct()
                .collect(Collectors.toMap(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(Integer key) {
                        return key;
                    }
                }, new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(Integer value) {
                        return value;
                    }
                }));*/
        Map<Integer,Integer> map=l2.stream().distinct()
                .collect(Collectors.toMap(k->k,v->v));
        System.out.println(map);
        // 求和 平均值 最大 最小
        Integer sum=l2.stream().collect(Collectors.summingInt(i->i));
        System.out.println(sum);
        Double avg=l2.stream().collect(Collectors.averagingDouble(i->i));
        System.out.println(avg);
        Optional<Integer> max=l2.stream()
                .collect(Collectors.maxBy(Comparator.comparingInt(i->i)));
        if(max.isPresent()){
            System.out.println(max.get());
        }
        Optional<Integer> min=l2.stream()
                .collect(Collectors.minBy(Comparator.comparingInt(i->i)));
        if(min.isPresent()){
            System.out.println(min.get());
        }
    }
}

7 Optional容器

  作用：防止集合中元素没有获取到从而出现空指向异常
  原理：通过制定方法获取集合中指定的元素，存放到optional容器中，此容器只能存放1个或0个元素，因此只需对容器判断即可

List<String> list=new ArrayList<>();
        /*String s=list.stream().findFirst(); // null
        System.out.println(s.length());  //NullpointException*/
        Optional<String> f=list.stream().findFirst();
        if(f.isPresent()){
            String s=f.get();
        }

四 分区和分组

1 作用

  分组:根据指定条件进行组别的划分

  分区:根据指定条件,只能将数据分为两个区域(一个是满足条件(true));一个是不满足条件(false)区域

2 例子

实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee {
    private String name;
    private Integer age;
    private Long id;
    private Integer kg;
}

测试类

public class EmployeeStreamTest {
    private static List<Employee> employees=new ArrayList<>();
    static {
        employees.add(new Employee("大黄",4,0301L,20));
        employees.add(new Employee("大白",4,0302L,18));
        employees.add(new Employee("小黑",2,0303L,12));
    }
    // 根据年龄分组
    @Test
    public void playGroup(){
        /*Map<Integer,List<Employee>> map=employees.stream()
                .collect(Collectors.groupingBy(new Function<Employee, Integer>() {
                    @Override
                    public Integer apply(Employee employee) {
                        return employee.getAge();
                    }
                }));*/
        Map<Integer,List<Employee>> map=employees.stream()
                .collect(Collectors.groupingBy(Employee::getAge));
        System.out.println(map);
        // {2=[Employee(name=小黑, age=2, id=195, kg=12)],
        // 4=[Employee(name=大黄, age=4, id=193, kg=20),
        // Employee(name=大白, age=4, id=194, kg=18)]}
    }
    // 通过体重进行分区 true>=18 false<18
    @Test
    public void playPart(){
        /*Map<Boolean,List<Employee>> map=employees.stream()
                .collect(Collectors.partitioningBy(new Predicate<Employee>() {
                    @Override
                    public boolean test(Employee employee) {
                        return employee.getKg()>=18;
                    }
                }));*/
        Map<Boolean,List<Employee>> map=employees.stream()
                .collect(Collectors.partitioningBy(p->p.getKg()>=18));
        System.out.println(map);
        // {false=[Employee(name=小黑, age=2, id=195, kg=12)],
        // true=[Employee(name=大黄, age=4, id=193, kg=20),
        // Employee(name=大白, age=4, id=194, kg=18)]}
        System.out.println(map.get(true));//体重不小于18kg的
        System.out.println(map.get(false));//体重小于18kg的
    }
}

五 并行和并发

1 并发

  单核操作,按照指定的顺序完成操作,适用于处理数据量较小的操作,效率高 --stream()

2 并行

  必须是多核操作,随机执行,适用于处理数据量较大的操作 – parallelStream

3 例子

public class PlayTest {
    @Test
    public void play(){
        List<String> list= Arrays.asList("大黄","大白","小黑");
        // 并发
        list.stream().forEach(System.out::println);
        // 并行
        list.parallelStream().forEach(System.out::println);
        // 并发转并行
        list.stream().parallel().forEach(System.out::println);
    }
}
泰勒疯狂展开
关注
  • 17
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java-lambda-stream
03-13
Java Lambda 和 Stream API 是 Java 8 引入的两个重要特性，它们极大地改变了Java程序员处理集合数据的方式，提升了代码的简洁性和可读性。这里我们将深入探讨这两个概念以及它们在实际编程中的应用。 Lambda表达式...
rtmp-rtsp-stream-client-java
05-21
【rtmp-rtsp-stream-client-java】项目是一个专门为Android平台设计的开源推流客户端库，它使得开发者能够轻松地在Android应用中实现RTMP和RTSP协议的视频直播功能。这个库提供了对实时媒体流传输协议的支持，允许...
javastream源码-demo-java-stream-collectors:“预定义的Java流收集器”文章和源代码
05-19
stream源码预定义的Java流收集器 介绍 有几种方法可以将Stream作为一系列输入元素简化为一个汇总结果。 其中之一是使用接口与方法的实现。 可以显式实现此接口，但是它应该从类中研究其预定义的实现开始。 预定义...
rtmp-rtsp-stream-client-java-master.zip
03-13
【rtmp-rtsp-stream-client-java-master.zip】这个压缩包文件是针对安卓平台的一个开源项目，主要用于实现RTMP和RTSP直播推流功能。在Android Studio 3.5及以上版本中开发，它允许用户将手机上的视频内容实时推送到...
java8-stream-examples
02-12
这个"java8-stream-examples"项目很显然是为了帮助开发者深入理解和掌握Java 8的流API。流API是一种处理数据集合的新方式，它允许我们以声明式的方式对数据进行操作，极大地提高了代码的可读性和简洁性。 1. **流的...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 599
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
操作系统原子操作
zzt_is_me的博客
08-28 5659
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
央顺科技官方博客
08-31 849
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
spring-data-redis中RedisRepository仓储
OceanSky的专栏
08-27 446
Id@RedisHash注解的value属性和@Id注解指定键值的命名空间，组合成user:id；@RedisHash的属性timeToLive属性指定键值的超时时间。CrudRepository接口中默认定义实现了save、saveAll、findById、existsById、findAll、findAllById、count、deleteById、delete、deleteAllById、deleteAll等方法，基本满足了对redis操作的需求；如果有特殊需求可以自定义实现。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 599
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
优秀的开源项目
猪猪
08-28 544
目录热key多线程并行秒级百G级日志工具ES操作工具消息推送平台HTTP 客户端业务层的分布式限流组件企业级微服务解决方案hotkey: 京东App后台中间件，毫秒级探测热点数据，毫秒级推送至服务器集群内存，大幅降低热key对数据层查询压力asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 478
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
SpringBoot SSM vue在线作业考试系统
yinjl123456的博客
08-30 351
使用技术: SpringBoot或SSM + Mybaits + Mysql + vue(前端)后台管理 登录注册 个人中心 教师信息管理 学生信息管理 学院信息管理 专业信息管理。班级信息管理 作业信息管理 作业提交管理 通知公告管理 试卷管理 试题管理。系统管理 管理员管理 考试管理。
Java并发编程 进程与线程
m0_56369671的博客
08-28 916
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
Java 虚方法表（虚函数）
最新发布
一心向阳，光芒万丈
08-31 405
虚方法表是一个类的内部数据结构，用于支持方法的动态绑定（即运行时多态）。每个类在加载时会生成一个虚方法表，其中包含了类中所有虚方法的地址。方法地址的存储：虚方法表存储了类的所有方法（包括继承自父类的方法）的内存地址或指针。这些方法在虚方法表中的顺序与它们在类中声明的顺序一致。动态绑定：当方法调用发生时，JVM 会根据对象的实际类型（而不是声明类型）来查找并调用正确的方法实现。这种机制允许程序在运行时决定调用哪个方法，从而实现多态。被privatestaticfinal。
功能强大的开源数据中台系统 DataCap 2024.03.9 发布
qianmoQ - 关注云计算,关注大数据
08-28 425
DataCap 发布！https://datacap.devlive.org/download.html
Java—Stream流
向上的咸鱼blueblue的博客
08-27 1471
本文详细介绍了JAVA中有关Stream的相关内容。
Java面试宝典-java基础02
杜盟恩的博客
08-27 1910
机器语言是一种指令集的体系，是最早出现的计算机语言。机器语言从属于硬件设备。不同的计算机设备有不同的机器语言．所以机器语言是一种面向机器的语言。计算机指令系统中的指令是由“0”和“1”两种符号组成的代码，并且能被机器直接理解执行，它们被称为机器指令。一个计算机的机器指令的集，就构成了该计算机的机器语言，即计算机可以直接接受、理解的语言。机器语言能利用机器指令精准地描述算法、且编程质量高、所占存储空间小，执行速度快。但是这种程序直观性很差，容易出错，阅读检查和修改调试非常困难。
Spring Boot如何解决跨域问题？
HBLOG
08-28 570
跨域请求，就是说浏览器在执行脚本文件的ajax请求时，脚本文件所在的服务地址和请求的服务地址不一样。说白了就是ip、网络协议、端口都一样的时候，就是同一个域，否则就是跨域。这是由于Netscape提出一个著名的安全策略——同源策略造成的，这是浏览器对JavaScript施加的安全限制。是防止外网的脚本恶意攻击服务器的一种措施。
java octet-stream转file对象
07-14
要将Java中的octet-stream数据转换为File对象，你可以按照以下步骤进行操作： 1. 首先，将octet-stream数据保存到一个临时文件中。你可以使用`File.createTempFile()`方法来创建一个临时文件对象。例如： ```java ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

泰勒疯狂展开

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

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

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

打赏作者

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

抵扣说明：

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

余额充值