Java8之Stream流化

最新推荐文章于 2022-04-21 23:36:43 发布
最新推荐文章于 2022-04-21 23:36:43 发布
阅读量436 收藏 1
点赞数 1
分类专栏： Java8 文章标签： stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42037775/article/details/107217830
版权

在这里插入图片描述

  • 例子：突出lambda表达式的优点；简化代码
/**
 * jdk1.8之前写法与jdk1.8现在写法 对比
 */
public class Demo1 {

    private static final List<String> STR_LIST = Lists.newArrayList("ab", "xyz", "789", "axy", "azzzzz", "a678", "a1234");

    public static void main(String[] args) {
        // 过滤字符串，找到以a开头的，排序，后生成一个字符串，并用，进行分割
        // abc,axy,azz -> "abc,axy,azz"

        foo1();

        foo2();
    }

    /**
     * 使用jdk1.8之前的原生写法
     */
    public static void foo1() {
        List<String> bufList = Lists.newArrayList();
        for (String s : STR_LIST) {
            if (!s.startsWith("a")) {
                continue;
            }

            bufList.add(s);
        }

        bufList.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }
        });

        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < bufList.size(); i++) {
            if (i == bufList.size() - 1) {
                builder.append(bufList.get(i));
                continue;
            }

            builder.append(bufList.get(i)).append(",");
        }

        String result = builder.toString();

        System.out.println("foo1 result = " + result);
    }

    /**
     * 使用jdk1.8 lambda+stream来处理
     */
    public static void foo2() {
        String result = STR_LIST.stream()
                .filter(str -> str.startsWith("a"))
                .sorted(Comparator.comparingInt(String::length))
                .collect(Collectors.joining(","));

        System.out.println("foo2 result = " + result);
    }
}

将集合流化

public static void main(String[] args) {
        List<String> strs = Lists.newArrayList("ab", "xyz", "789", "axy", "azzzzz", "a678", "a1234");
        Set<String> sets = Sets.newHashSet();
        int[] arr = new int[10];

       
        // 2.并行流
        strs.parallelStream();
        sets.parallelStream();
  • 创建普通流
    正常操作 ，数据量比较小
 // 1.流化操作,普通流
        strs.stream();
        sets.stream();
        Arrays.stream(arr);
  • 创建并行流
    数据量比较大，提升效率，提升性能（上w，几十w）
    在这里插入图片描述
 // 1.流化操作,普通流
        strs.stream();
        sets.stream();
        Arrays.stream(arr);

中间操作，过滤器，filter演示

 private static void testFilter(List<String> strs) {
        strs.stream()
                //第一个过滤器，长度大于等于5；第二个过滤器已b开头；二个条件需全部满足
                .filter(str -> str.length() >= 5)
                .filter(str -> str.startsWith("b"))
                .forEach(str -> System.out.println("str=" + str));
    }

中间操作 映射操作

private static void testMap(List<String> strs) {
        strs.stream()
                .map(str -> str.toUpperCase())
                .map(str -> str +";")
                .forEach(str -> System.out.println("str="+str));

结果

str=AB;
str=BYZ;
str=789;
str=AXY;
str=AZZZZZ;
str=A678;
str=A1234;
str=B1236;

中间操作 排序

 private static void testSort(List<String> strs) {
        //默认的排序方式
        strs.stream()
                .sorted().forEach(str -> System.out.println("str = " + str));
        System.out.println("=================");
        strs.stream()
                .sorted().sorted(Comparator.comparingInt(String::length)).forEach(str -> System.out.println("str = " + str));

中间操作： skip +limit

 /**
     * 中间操作： skip +limit
     * 跳过几个，限制几行；类似分页
     * @param strs
     */
    private static void testLimitAndSkip(List<String> strs) {
        strs.stream()
                .skip(2)
                .limit(3)
                .forEach(str -> System.out.println("str = " + str));

    }

中间操作 peek

我们看不到流的操作，想看的话，就用peek；
不改变数据，输出每个节点的数据
在这里插入图片描述

中间操作 flatMap（（对流扁平化处理）） ------难点

 private static void testFlatMap() {
        List<List<String>> strsList = Lists.newArrayList();

        List<String> strs1 = Lists.newArrayList("ab", "byz", "789");
        List<String> strs2 = Lists.newArrayList("abc", "byz", "89y");
        List<String> strs3 = Lists.newArrayList("yab", "byc", "sdf");

        strsList.add(strs1);
        strsList.add(strs2);
        strsList.add(strs3);

        // -------
        // 需求: 将大集合中的所有字符串 全部转成大写
        // 用之前所学的转化操作，就这样搞，但是比较恶心.
        // Stream<List<String>> stream = strsList.stream();
        // stream.forEach(strList -> {
        //     strList.stream().map(String::toUpperCase).forEach(str -> {
        //         System.out.println("str = " + str);
        //     });
        // });

        strsList.stream()
                // FlatMap做了啥
                // .flatMap(list -> list.stream())
                // .map(str -> str.toUpperCase())
                .flatMap(Collection::stream)
                .map(String::toUpperCase)
                .forEach(str -> System.out.println("str = " + str));

下图是运用flatMap的stream运行流程

结束操作

结束操作


 *   --直接拿到结果
 *        + count
 *        + findFirst
 *        + findAny
 *        + forEach
 *
 *   做统计，collect*

count -统计结果

 private static void testCount(List<String> strs) {
        long count = strs.stream()
                .filter(str -> str.length() > 3)
                // .forEach(str -> System.out.println("str=" + str));
                .peek(str -> System.out.println("str = " + str))
                .count();
        System.out.println("count = " + count);
    }

FindFirst -首个

  private static void testFindFirst(List<String> strs) {
        Optional<String> optional = strs.stream()
                .filter(str -> str.startsWith("a")).findFirst();
        if (optional.isPresent()) {
            String val = optional.get();
            System.out.println("val = " + val);
        }
    }
  • Optional详解-tudo
    在这里插入图片描述

collect操作

Collectors.toSet() ，转成List（集合）

 private static void testCollectToSet(List<String> strs) {
        Set<String> data = strs.stream()
                .filter(str -> str.length() > 3)
                .map(str -> str + "*")
                .collect(Collectors.toSet());
        System.out.println("data = " + data);
    }

结果

data = [b1236*, y123*, x123*, a678*, axylonglog*, a12345*, z123*, azzzzz*]

Collectors.toMap(),转成k，v形式

  private static void testCollectToMap(List<String> strs) {
        Map<String, Integer> data = strs.stream()
                .filter(str -> str.length() > 3)
                .map(str -> str + "*")
                .distinct()
                .collect(Collectors.toMap(str -> str, str -> str.length()));
        data.forEach((k,v)->{
            System.out.println("data map k = " + k+",v="+v);
        });
    }

结果

data map k = b1236*,v=6
data map k = y123*,v=5
data map k = x123*,v=5
data map k = a678*,v=5
data map k = axylonglog*,v=11
data map k = a12345*,v=7
data map k = z123*,v=5
data map k = azzzzz*,v=7

Collectors.groupingBy() ,分组

 private static void testGroupBy(List<String> strs) {
        Map<Integer, List<String>> data = strs.stream()
                .filter(str -> !Strings.isNullOrEmpty(str))
                .collect(Collectors.groupingBy(str -> str.length()));
        data.forEach((k,v)->{
            System.out.println("所属长度="+k);
            System.out.println("     数据内容=="+v);
            System.out.println("\n");
        });
    }

结果

所属长度=2
     数据内容==[ab]


所属长度=3
     数据内容==[byz, 789]


所属长度=4
     数据内容==[a678, x123, y123, z123]


所属长度=5
     数据内容==[b1236]


所属长度=6
     数据内容==[azzzzz, azzzzz, azzzzz, azzzzz, a12345, a12345, a12345]


所属长度=10
     数据内容==[axylonglog]

Collectors.partitioning(),已xxx条件分区

在这里插入图片描述

    private static void testPartitioning(List<String> strs) {
        Map<Boolean, List<String>> data = strs.stream()
                .filter(str -> !Strings.isNullOrEmpty(str))
                .collect(Collectors.partitioningBy(str -> str.length() > 5));

        data.forEach((k,v)->{
            if(k){
                System.out.println("分区字符串长度大于5："+v);
            }else {
                System.out.println("分区字符串长度小于5："+v);
            }
        });
    }

结果

分区字符串长度小于5：[ab, byz, 789, a678, b1236, x123, y123, z123]
分区字符串长度大于5：[axylonglog, azzzzz, azzzzz, azzzzz, azzzzz, a12345, a12345, a12345]

Collectors.joining(),已xx连接

  private static void testJoining(List<String> strs) {
        String data = strs.stream()
                .filter(str -> !Strings.isNullOrEmpty(str))
                .collect(Collectors.joining("+"));
        System.out.println("data = " + data);
    }

结果

data = ab+byz+789+axylonglog+azzzzz+azzzzz+azzzzz+azzzzz+a678+a12345+a12345+a12345+b1236+x123+y123+z123
mlong_QA
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java8新特性之Stream
葵花点穴手
08-05 296
Stream简介：     java8随着lambda表达式的加入，又加入了Stream（流），什么是流呢？书上是这样定义的“从支持数据处理操作的源生成的元素序列”， 元素序列——就像集合一样，流也提供了一个接口，可以访问特定元素类型的一组有序值。 源——流会使用一个提供数据的源，如集合、数组或输入/输出资源。 数据处理操作——流的数据处理功能支持类似于数据库的操作，以及函数式编程语言中的常用操作...
Stream流(Java8)
weixin_54517901的博客
04-26 97
Stream流 1.流stream：保存对集合或数组数据的操作，和集合类似，但集合中保存的是数据 1.1 特点： stream 自己不会存储元素 stream 不会改变源对象，相反，会返回一个持有结果的新stream stream 操作是延迟执行的，意味着他们会等到需要结果的时候才执行 1.2 步骤： 1.创建 新建一个流 2.中间操作 在一个或多个步骤中，将初始stream转化到另一个stream的中间操作 3.终止操作 使用一个终止操作来产生一个结果，该操作会强制它之前的延迟操作立即执行，之后
流与文件 java_流与文件-（java核心技术）
weixin_26802933的博客
02-22 169
1.1 流1.2 文本输入与输出1.2.1 如何写出文本输出1.2.2 如何读入文本输入1.2.3 以文本格式存储对象1.2.4 字符集1.3 读写二进制数据1.4 ZIP文档·Enumeration entries()返回一个Enumeration对象，它枚举了描述这个ZipFile中各个项的ZipEntry对象。·ZipEntry getEntry(String name)返回给定名字所对应的...
java 怎么把list流化,Java Streams 8个很酷的特性
weixin_42494891的博客
03-14 142
本文由ImportNew-陈 晓舜翻译自 speling.shemnon 。欢迎加入 Java小组 。转载请参见文章末尾的要求。Lambda表达式是目前Java8最酷的特性之一。但我认为还有一项秘密武器类似于“语法糖”在提升代码可读性和可塑性很强大。当你使得代码更富有表现力时，它可以使你的任务中最困难的部分简单化，且能够表现更深的含义。那个秘密武器？就是Java Strea...
java8的核心特征：Lambda、流、默认方法---初级篇（一）
weixin_41670928的博客
04-28 587
讨论java的新特性之前，先来聊聊轻松的东西---java为什么还在变？和大自然中所有的生物一样，为了生存下去，必须不断进化，否则就会被淘汰。语言也是一样的，不进化，不变，就会被更好的语言淘汰。20世界60年代，就已经有700种编程语言了。之后更是出现了数以千计的编程语言。学者们得出结论：编程语言就像生态系统一样，新的语言会出现，旧的语言则被取代，除非它们不断演变。我们都希望出现一种完美的语言，可...
浅谈java8 stream flatMap流的扁平化操作
08-24
浅谈 Java8 Stream flatMap 流的扁平化操作 Java8 中的 Stream 是一个新概念，它不是输入输出的 Stream 流，而是一种用函数式编程方式在集合类上进行复杂操作的工具。Stream 提供了两种操作：中间操作和终止操作。...
Java8新特性Stream流实例详解
08-29
Java8新特性Stream流实例详解 Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。...
Java8Test.java_java8_almosttog_stream流_
09-29
Java 8是Java语言的一个重要版本，引入了许多新特性，其中Stream API是其最显著的改进之一。Stream API提供了一种新的数据处理方式，使得在集合上进行操作更加简洁、高效。本文将深入探讨Java 8 Stream API的基础...
Java 8 之 流（Stream）
08-05
// 将数据流化 Stream<Row> rowStream = sheet.stream().skip(1); // 跳过表头 // 进行数据处理 rowStream.filter(row -> row.getCell(1).getNumericCellValue() > 100) .sorted(Comparator.comparingDouble(Row::...
Java8中Stream使用的一个注意事项
08-28
Java 8 中的 Stream 是一个强大的工具，它引入了一种新的数据处理方式，特别是对于集合对象的操作。Stream 不是存储数据的数据结构，而是用于处理数据的 API，它提供了丰富的操作，如过滤、映射、聚合等，使得代码...
大白话之Java Stream流：将类数组流化，便捷批量修改，通俗讲解！
_Adler.
10-31 1699
https://stackoverflow.wiki/blog/articles/2019/08/12/1565616272019.html
把数据流化：Stream API
weixin_34274029的博客
12-04 355
Java8引入了与此前完全不同的函数式编程方法，通过Lambda表达式和StreamAPI来为Java下的函数式编程提供动力。本文是Java8新特性的第二篇，旨在展示Stream API是如何简化程序编写并且体现出函数式编程的美感的，在Stream的世界里面，数据在概念上不再只是内存中存储的字节，而更像是流动的活跃生物。 最近在读这本图...
java8流式处理
jeason_chan_zju的博客
07-16 2285
流式处理简介 https://www.cnblogs.com/shenlanzhizun/p/6027042.html java8，即jdk1.8中新增的内容， 转换流 中间操作 终端操作
java基础——I/O流
jiangmanshan的博客
11-25 729
字节流和字符流
Stream流式处理详解(通俗易懂)
weixin_68463442的博客
04-21 3065
Stream介绍：在没有Stream之前，我们普遍都是使用for循环对集合或者数组进行处理，过程繁琐且代码凌乱，Stream流就很好的解决了这个问题。是我们的代码看起来更加的优雅！ 优点： 1.直接阅读代码的字面意思即可完美展示无关逻辑方式的语义。 2.Stream流把真正的函数式编程风格引入到Java中，使我们的代码更加简洁且优雅。 好了！我们开始进入正题吧，来看一下Stream流的优雅吧！ 首先我们在集合中添加一些数据，过滤出开头为李的名称并且只要长度为2的数据。一句代码的是，是特别优雅.
java 怎么把list流化_Java 中的数据流和函数式编程
weixin_39716044的博客
03-07 580
原标题：Java 中的数据流和函数式编程 学习如何使用 Java 8 中的流 API 和函数式编程结构。-- Marty Kalin(作者)当 Java SE 8(又名核心 Java 8)在 2014 年被推出时，它引入了一些更改，从根本上影响了用它进行的编程。这些更改中有两个紧密相连的部分：流 API 和函数式编程构造。本文使用代码示例，从基础到高级特性，介绍每个部分并说明它们之间的相互作用。基...
java 怎么把list流化_java8新概念之stream流
weixin_29532927的博客
03-01 422
1.什么是stream大家可以把Stream当成一个高级版本的Iterator。原始版本的Iterator，用户只能一个一个的遍历元素并对其执行某些操作；高级版本的Stream，用户只要给出需要对其包含的元素执行什么操作，比如“过滤掉长度大于10的字符串”、“获取每个字符串的首字母”等，具体这些操作如何应用到每个元素上，就给Stream就好了！2.Stream与Collection比较Stream...
Java8 Stream流操作
疯狂的蜗牛
08-26 2702
java8中的流式操作是一个很重要的内容 上图列出了stream主要流操作，我们可以看到，其实流操作可以类比我们的sql语句，如filter就类似于sql的where语句，我们就知道filter是对流进行过滤的，传入了一个Predicate断言接口，过滤掉断言为false的数据。相比一起的循环迭代，移除不符合的数据，是不是更加方便。下面我们来详细说说。 1、filter 过滤，传入一个Predicate @Test public void testFilter() { Stream<Inte
Java8 Stream流与方法引用详解
"Java8新特性，包括Stream流和方法引用的详解" 在Java8中，引入了Stream API，这是一个重大革新，它为处理集合数据提供了全新的方式，尤其是在函数式编程场景下。Stream流并不像传统的集合那样关注数据存储，而是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值