java基础巩固——stream流

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量749 收藏 1
点赞数
文章标签： java 开发语言 spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pedri_/article/details/129816728
版权

1.stream流的意义

  1. 与相同功能的操作相比，Stream流的代码量小，代码更高级。
  2. Stream流在面向大的数据时，执行效率更高。
  3. 使用Stream流的操作时不占用存储（原因是stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成）。
  4. Stream流的思想大致可以理解为一条流水线，经过我们规定的方式去加工产品，经过多道工序后，最终就得到了我们想要的最终产品。

 2.不同集合或数据存储类型获取Stream流方法

  • 单列集合

  • 使用Collection类(单列集合的父接口)的默认方法 stream()
  • public class getStream {
    public static void main(String[] args) {
        //单列集合 获取stream流的方法
        //使用Collection类(单列集合的父接口)的默认方法
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张无忌");
        list.add("赵敏");
        list.add("周芷若");
        list.add("金毛狮王");
        list.add("张三丰");
        list.add("李连杰");
        list.stream().forEach(name -> System.out.println(name));
    }
}

     双列集合

  • 双列集合不能直接使用stream流，只能通过间接的方式来使用，比如它的keyset,value,entrySet来使用

  • public class getStream {
    public static void main(String[] args) {
        //双列集合 keyset,value,entrySet 来使用stream流
        HashMap<String, String> map = new HashMap<>();
        map.put("张三","上海");
        map.put("李四","北京");
        map.put("王五","重庆");
        map.keySet().stream().forEach(key -> System.out.println(key+"=="+map.get(key)));
        map.values().stream().forEach(value -> System.out.println(value));
        map.entrySet().stream().forEach(entry -> System.out.println(entry));
    }
}

    数组和杂乱数据

  • 数组一般使用数组工具类Arrays中的stream()方法来获取流，也可以使用Stream接口的静态方法of()来获取流(这种方法实质上也是第一种方法)
public class getStream {
    public static void main(String[] args) {
        //数组
        int[] nums = {1,2,3,4,5};
   //     Arrays.stream(nums).forEach(num -> System.out.println(num));
        //如果是基本数据类型数组 则存的是整体
        Stream.of(nums).forEach(num -> System.out.println(num));

        Stream.of("1","2","3").forEach(num -> System.out.println(num));
    }
}

 3.Stream流中的方法

Stream流中的方法分为两种 中间方法 和 终结方法

中间方法

中间方法返回新的Stream流,原来的Stream流只能用一次,建议使用链式编程。只会修改流中的数据，并不会影响到集合或数组原有的数据。

public class middleStream {
    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("李连杰");
        //filter
        //可以使用匿名内部类 和 lambda两种方式
        System.out.println("============filter===========");
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张");
            }
        }).forEach(name -> System.out.println(name));
        System.out.println("=======================");
        list.stream().filter(name -> name.startsWith("张")).forEach(name -> System.out.println(name));
        System.out.println("==========skip=============");

        //limit 获取前几个
        //skip 跳过前几个
        list.stream().limit(3).forEach(name -> System.out.println(name));
        System.out.println("=======================");
        list.stream().skip(3).forEach(name -> System.out.println(name));

        //distinct 去重
        //底层是equals + hashcode 所以 如果集合里面存的是对象 需要重新方法
        System.out.println("=========distinct========");
        list.add("张无忌");
        System.out.println(list);
        list.stream().distinct().forEach(name -> System.out.println(name));

        //concat 合并两个流
        System.out.println("=========concat========");
        ArrayList<Object> list1 = new ArrayList<>();
        list1.add("孙悟空");
        list1.add("猪八戒");
        Stream.concat(list.stream(),list1.stream()).forEach(name -> System.out.println(name));

        //map 转换流中的数据类型
        System.out.println("=========map========");
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("1");
        list2.add("2");
        list2.add("3");
        //使用匿名内部类
//        list2.stream().map(new Function<String, Integer>() {
//            @Override
//            public Integer apply(String s) {
//                return Integer.parseInt(s);
//            }
//        }).forEach(num -> System.out.println(num));
        //lambda
        list2.stream().map(num -> Integer.parseInt(num)).forEach(num -> System.out.println(num.getClass()));
    }
}

终结方法

 

 

public class middleStream {
    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("李连杰");
        //forEach 遍历
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("==============");
        list.stream().forEach(s -> System.out.println(s));

        //count 统计
        System.out.println(list.stream().count());

        //toArray 收集流中的数据 放到数组中
        String[] array = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        Arrays.stream(array).forEach(s -> System.out.println(s));
        System.out.println("=========");
        String[] array1 = list.stream().toArray(value ->
                new String[value]);
        Arrays.stream(array1).forEach(s -> System.out.println(s));
    }
}

collect:

public class stream_collect {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌-男-20","周芷若-女-18","张翠山-男-40","张三丰-男-80","赵敏-女-23");
        //收集所有的男性
        //方式1
        list.stream().filter(s -> "男".equals(s.split("-")[1])).forEach(s -> System.out.println(s));
        System.out.println("==============");
        //方式2 收集到list
        List<String> myList = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());
        System.out.println(myList);
        System.out.println("==============");
        //方式3 收集到Set
        Set<String> mySet = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toSet());
        System.out.println(mySet);
        //方式4 收集到Map 需要注明键值的规则
        //参数1 键的生成规则 参数2 值的生成规则
        //匿名内部类的方式
        //Function<泛型1,泛型2> 泛型1是流中的数据类型 泛型2是目标键(值)的类型
        System.out.println("==============");
        Map<String, Integer> map = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.split("-")[0];
            }
        }, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s.split("-")[2]);
            }
        }));
        System.out.println(map);
        //lambda表达式的方式
        System.out.println("=============lambda=========");
        Map<String, Integer> myMap = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(
                s -> s.split("-")[0],
                v -> Integer.parseInt(v.split("-")[2])
        ));
        System.out.println(myMap);
    }
}

总结：

        经过本次针对于Stream流的学习，加深了我对Stream流的理解，使用Stream流也更加熟练。在此之前，我只是简简单单的调用其方法大致了解含义，甚至不是很理解为什么要这么做，对一些稍微复杂的Stream流操作也看不懂。所以，这次学习是非常有必要的，我深刻的感受到了Stream流的强大，以后很多集合数组操作，Stream流必然成为我的首选。

Pedri_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java8 Stream 数据流，大数据量下的性能效率怎么样？
m0_64867220的博客
12-04 2279
stream 对于终端操作，可以直接提供一个中间操作的结果，或者将结果转换为特定的 collection、array、String 等； stream 的特点 ①只能遍历一次： 数据流的从一头获取数据源，在流水线上依次对元素进行操作，当元素通过流水线，便无法再对其进行操作，可以重新在数据源获取一个新的数据流进行操作； ②采用内部迭代的方式： 对Collection进行处理，一般会使用 Iterator 遍历器的遍历方式，这是一种外部迭代； 而对于处理Stream，只要申明处理方式，处理过程由流对象自行.
JDK8 Stream 数据流效率分析，Java开发你需要了解的那些事
m0_60746463的博客
08-11 224
此外还有一系列特化流，如 IntStream，LongStream，DoubleStream等 ），Java 8 引入的的Stream主要用于取代部分Collection的操作，每个流代表一个值序列，流提供一系列常用的聚集操作，可以便捷的在它上面进行各种运算。 集合类库也提供了便捷的方式使我们可以以操作流的方式使用集合、数组以及其它数据结构； 作为阅读福利，小编也整理了一些Java学习笔记（包含面试真题+脑图+手写pdf等）现在免费分享给阅读到本篇文章的Java程序员朋友们，需要的自行领取~ 最全学习笔记大
for、foreach、stream 哪家的效率更高，你真的用对了吗？
代码界的扛把子
11-20 445
public static void formMethod(List lists){ lists.stream().forEach(i->{ System.out.println("__________stream处理____________");Stream的优势在于，提供了并行处理（parallelStream()方法），即stream api提供了异步处理机制，可以充分利用CPU核数，大大提升效率！添加图片注释，不超过 140 字（可选）添加图片注释，不超过 140 字（可选）
JDK8 Stream 数据流效率分析
2401_84048467的博客
04-09 974
可能有人会问我为什么愿意去花时间帮助大家实现求职梦想，因为我一直坚信时间是可以复制的。我牺牲了自己的大概十个小时写了这片文章，换来的是成千上万的求职者节约几天甚至几周时间浪费在无用的资源上。上面的这些（算法与数据结构）+（Java多线程学习手册）+（计算机网络顶级教程）等学习资源《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！以复制的。我牺牲了自己的大概十个小时写了这片文章，换来的是成千上万的求职者节约几天甚至几周时间浪费在无用的资源上。
java stream
12-02
java stream doc.
使用java中的流stream快速遍历
2301_77519619的博客
01-27 378
Arrays.stream(arr).filter(item->{ //filter过滤。}).forEach(item->{ //foreach遍历。流：顾名思义就像水流，它只流一次，在这一次过程中对其中的元素进行操作。}).map(item->{ //map拆箱。3.如果是集合类，继承了Collection的.strean。实际应用：把数组中的元素的奇数删除再把剩下元素×2再输出。2.使用数组的Arrays.stream。在使用流时，流会一去不复返。
【Java】stream效率问题
fearless的博客
08-10 1846
对于stream的效率问题，来做一下测试： 自定义类型： @Data public class StreamEntity { private Long id; private String name; private Integer value; } 测试类： public class StreamTest { @Test public void streamEfficiency(){ List<Integer> integerL
Java 8 Stream 数据流效率分析
程序猿DD
07-09 1225
来源：https://blog.csdn.net/Al_assad/article/details/82356606Stream 是Java SE 8类库中新增的关键抽象，它被定义于 java.util.stream （这个包里有若干流类型：Stream代表对象引用流，此外还有一系列特化流，如 IntStream，LongStream，DoubleStream等 ），Ja...
Java Stream 流实现合并操作示例
08-19
主要介绍了Java Stream 流实现合并操作,结合实例形式详细分析了Java Stream 流实现合并操作原理与相关注意事项,需要的朋友可以参考下
Java-IO流/Stream流总结
07-12
Java-IO流/Stream流总结，内容一针见血，没有废话，言简意赅 内容：IO流及其分类、分类比较、转换流、缓存流、IO流异常处理、Stream流、Properties教程等。 适合人群：有编程基础及Java基础伙伴 适用场景：Java中的...
Java8新特性Stream流实例详解
08-29
Stream流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。这篇文章主要介绍了Java8新特性Stream流的相关资料，需要的朋友参考下吧
详解JAVA Stream流
08-18
主要介绍了JAVA Stream流的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Java Stream 流的使用过程解析
08-25
主要介绍了Java Stream 流的使用过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java Stream常见用法汇总，开发效率大幅提升
Tyson0314的博客
04-14 1153
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来对 Java 集合运算和表达的高阶抽象。Stream API 可以极大提高 Java 程序员的生产力，让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
java 8 stream效率低_Java8 新特性连载番外篇——Stream真的效率低吗
weixin_32848231的博客
02-26 300
自从Java8推出之后，Stream新特性就被广泛关注，我在前几篇也着重介绍了一下，从编写程式码角度确实要比之前干净、优雅得多，但是有一个问题一直有争议，那就是效能问题，用了Stream效率会不会降低?真的会出现网上所说的效率低20倍吗？网上测评文章也很多，莫衷于世，众说纷纭，这两天闲来无事，我也对此进行了测试：测试机器机器1：双核8G内存机器2：四核16G内存测试资料：一个有10000000个随...
Java Stream流使用及性能分析
weixin_46822367的博客
01-20 7447
Java Stream流 一、Stream简介 1、什么是Stream? Java8 中，Collection 新增了两个流方法，分别是 Stream() 和 parallelStream() Java8 中添加了一个新的接口类 Stream，相当于高级版的 Iterator，它可以通过 Lambda 表达式对集合进行大批量数据操作，或 者各种非常便利、高效的聚合数据操作。 2、为什么要使用Stream? 在 Java8 之前，我们通常是通过 for 循环或者 Iterator 迭代来重新排序合并
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1008
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 805
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 296
【代码】Java手动启动jar包。
stream流倒序排序_Java8新特性——强大的Stream
05-24
以下是一个示例代码，演示了如何使用 Java 8 中的 Stream 流对集合进行倒序排序： ```java import java.util.Arrays; import java.util.Comparator; import java.util.List; public class StreamTest { public ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值