码农知识堂 - 1000bd
  •   Python
  •   PHP
  •   JS/TS
  •   JAVA
  •   C/C++
  •   C#
  •   GO
  •   Kotlin
  •   Swift

  • 5.1 Stream介绍和实战

    文章目录

    • Stream介绍和实战
      • 1. Stream简介
        • 1.1 官方说明
        • 1.2 语法
        • 1.3 特点
      • 2. 组成
        • 2.1 源头
        • 2.2 中间操作
        • 2.3 终止操作
      • 3. 案例
        • 3.1 中间操作案例
          • 1. filter过滤
          • 2.1. map用法1，提取code
          • 2.2. map用法2，便利修改当前对象，不产生新对象
          • 3. flatMap,将一个Stream中的每个元素转换为另一个Stream，然后将所有转换后的Stream合并为一个新的Stream
          • 4. sort
          • 5. skip
          • 6. limit
          • 7. distinct
        • 3.2 终止操作案例
          • 1. reduce:
          • 2. foreach:
          • 3. collect:
          • 4. allMatch:
          • 5. anyMatch:
          • 6. noneMatch:
          • 7. findFirst:
          • 8. findAny:
          • 9. max:
          • 10. min:
          • 11. count:

    Stream介绍和实战

    1. Stream简介

    1.1 官方说明

    Stream官方地址，简单说Stream可以对集合进行各种非常高效的操作，配合上Lambda表达式，让代码更简洁。

    1.2 语法

    例如：

 int sum = widgets.stream()
                  .filter(b -> b.getColor() == RED)
                  .mapToInt(b -> b.getWeight())
                  .sum();
我们使用widgets，一个Collection，作为流的源，并在流上执行过滤-映射-归约操作，以获得红色小部件的重量总和。（求和是归约操作的一个示例。）

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    1.3 特点

    该包引入的关键抽象是流（stream）。Stream、IntStream、LongStream 和 DoubleStream 这些类是对象和原始 int、long 和 double 类型的流。流与集合在几个方面有所不同：

    1. 无存储。流不是存储元素的数据结构；相反，它通过计算操作的管道，从数据结构、数组、生成器函数或 I/O 通道等源传递元素。
    2. 函数式特性。对流的操作会产生结果，但不会修改其源。例如，对从集合获取的流进行过滤会生成一个新的流，而不是从源集合中删除元素。
    3. 寻求惰性。许多流操作，如过滤、映射或去重，可以实现惰性执行，从而提供优化机会。例如，“找到具有三个连续元音字母的第一个字符串”不需要检查所有输入字符串。流操作分为中间（生成流）操作和终端（产生值或副作用）操作。中间操作总是惰性执行。
    4. 可能无界。集合具有有限大小，而流则不一定。诸如 limit(n) 或 findFirst() 之类的短路操作可以使对无限流的计算在有限时间内完成。
    5. 可消费。流的元素在流的生命周期内只被访问一次。与迭代器类似，要重新访问源的相同元素，必须生成一个新的流。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    2. 组成

    一个stream操作主要有3个部分：源头、中间操作、终止操作。
    中间操作可以有0个或多个，但不是立马执行的，只有终止操作被调用后中间操作才会一起执行（惰性执行）

    2.1 源头

    一般有

    数组
int[] demoArr = new int[]{2,4,6,1};
Arrays.stream(demoArr);
Stream.of(demoArr);

集合Collection
List demoList = new ArrayList<>();
demoList.stream();
Stream.of(demoList);;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
     

    2.2 中间操作
     

    一般有
     

    filter      条件过滤
map         对流中的每个元素按照指定的映射规则进行转换
flatmap     将每个元素映射成一个流，然后将所有流合并成一个流的方法。这个方法通常用于将嵌套的集合展开成一个扁平的流。
sorted      按照规则排序
skip        跳过指定数量的元素，返回一个包含剩余元素的新流
limit       数量限制
distinct    去重

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
     

    2.3 终止操作
     

    一般有
     

    reduce
foreach
collect
allMatch
anyMatch
noneMatch
findFirst
findAny
max
min
count

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
     

    3. 案例
     

    3.1 中间操作案例
     

    通用参数
     

    List userList = new ArrayList<>();
User userYang = new User("1", "小杨", 18);
userList.add(userYang);
User userWang = new User("2", "小王", 16);
userList.add(userWang);
User userLi = new User("3", "小李", 20);
userList.add(userLi);
List list1 = Arrays.asList("hello", "world");
List list2 = Arrays.asList("java", "stream");

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
     

    1. filter过滤
     

    userList.stream()
        .filter(item -> item.getCode().equals("1"))
        .forEach(item -> {
            System.out.println(item.getName());
        });

输出: 小杨

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
     

    2.1. map用法1，提取code
     

    List codeList = userList.stream().map(User::getCode).collect(Collectors.toList());
System.out.println(JSON.toJSONString(codeList));

输出: ["1","2","3"]

    • 1
    • 2
    • 3
    • 4
     

    2.2. map用法2，便利修改当前对象，不产生新对象
     

    userList.stream().map(item -> {
    item.setAge(18);
    return item;
}).collect(Collectors.toList());
System.out.println(JSON.toJSONString(userList));

输出: [{"age":18,"code":"1","name":"小杨"},{"age":18,"code":"2","name":"小王"},{"age":18,"code":"3","name":"小李"}]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
     

    3. flatMap,将一个Stream中的每个元素转换为另一个Stream，然后将所有转换后的Stream合并为一个新的Stream
     

    List result = Stream.of(list1, list2)
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
System.out.println(result);

输出: [hello, world, java, stream]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
     

    4. sort
     

    List sortUserList = userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
System.out.println(JSON.toJSONString(sortUserList));

输出: [{"age":16,"code":"2","name":"小王"},{"age":18,"code":"1","name":"小杨"},{"age":20,"code":"3","name":"小李"}]

    • 1
    • 2
    • 3
    • 4
     

    5. skip
     

    List skipUserList = userList.stream().skip(1).collect(Collectors.toList());
System.out.println(JSON.toJSONString(skipUserList));

输出: [{"age":16,"code":"2","name":"小王"},{"age":20,"code":"3","name":"小李"}]

    • 1
    • 2
    • 3
    • 4
     

    6. limit
     

    List limitUserList = userList.stream().limit(1).collect(Collectors.toList());
System.out.println(JSON.toJSONString(limitUserList));

输出: [{"age":18,"code":"1","name":"小杨"}]

    • 1
    • 2
    • 3
    • 4
     

    7. distinct
     

    User userLiCopy = new User("3", "小李", 20);
userList.add(userLiCopy);
List distinctUserList = userList.stream().distinct().toList();
System.out.println(JSON.toJSONString(distinctUserList));

输出: 添加一个重复元素之后去重， [{"age":18,"code":"1","name":"小杨"},{"age":16,"code":"2","name":"小王"},{"age":20,"code":"3","name":"小李"}]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
     

    3.2 终止操作案例
     

    1. reduce:
     

    List numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce(0, (acc, x) -> acc + x);
System.out.println("Sum of numbers: " + sum);

输出: Sum of numbers: 15

    • 1
    • 2
    • 3
    • 4
    • 5
     

    2. foreach:
     

    List names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream().forEach(System.out::println);

输出: 
 Alice
 Bob
 Charlie

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
     

    3. collect:
     

    List numbers = Arrays.asList(1, 2, 3, 4, 5);
List squares = numbers.stream().map(x -> x * x).collect(Collectors.toList());
System.out.println("Squares of numbers: " + squares);

输出: Squares of numbers: [1, 4, 9, 16, 25]

    • 1
    • 2
    • 3
    • 4
    • 5
     

    4. allMatch:
     

    List numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean allEven = numbers.stream().allMatch(x -> x % 2 == 0);
System.out.println("Are all numbers even? " + allEven);

输出:  Are all numbers even? false

    • 1
    • 2
    • 3
    • 4
    • 5
     

    5. anyMatch:
     

    List numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean anyEven = numbers.stream().anyMatch(x -> x % 2 == 0);
System.out.println("Are there any even numbers? " + anyEven);

输出: Are there any even numbers? true

    • 1
    • 2
    • 3
    • 4
    • 5
     

    6. noneMatch:
     

    List numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean noneNegative = numbers.stream().noneMatch(x -> x < 0);
System.out.println(noneNegative);

输出: true

    • 1
    • 2
    • 3
    • 4
    • 5
     

    7. findFirst:
     

    List names = Arrays.asList("Alice", "Bob", "Charlie");
Optional first = names.stream().findFirst();
System.out.println("First name: " + first.orElse("None"));

输出： First name: Alice

    • 1
    • 2
    • 3
    • 4
    • 5
     

    8. findAny:
     

    List names = Arrays.asList("Alice", "Bob", "Charlie");
Optional any = names.stream().findAny();
System.out.println("Any name: " + any.orElse("None"));

输出: Any name: Alice

    • 1
    • 2
    • 3
    • 4
    • 5
     

    9. max:
     

    List numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional maxNum = numbers.stream().max(Integer::compare);
System.out.println("Max number: " + maxNum.orElse(0));

输出: Max number: 5

    • 1
    • 2
    • 3
    • 4
    • 5
     

    10. min:
     

    List numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional minNum = numbers.stream().min(Integer::compare);
System.out.println("Min number: " + minNum.orElse(0));

输出: Min number: 1

    • 1
    • 2
    • 3
    • 4
    • 5
     

    11. count:
     

    List numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream().count();
System.out.println("Number of elements: " + count);

输出：Number of elements: 5

    • 1
    • 2
    • 3
    • 4
    • 5
    
                
                    
                

                
  • 

                    相关阅读:
    
                    
Linux网络编程- ioctl()结合struct ifreq使用案例                            
    
Alphago Zero的原理及实现：Mastering the game of Go without human knowledge                            
    
关于安卓卡片式交互实现（recyclerview）                            
    
SpringBoot快速复习                            
    
【Java基础】异常概述、try-catch、throws方式处理异常及自定义异常                            
    
Leetcode 84.柱状图中最大的矩形                            
    
项目日历是什么？如何规划？                            
    
Android开发笔记——快速入门（从入门SQLlite到Room放肆）2                            
    
SpringBoot——》@KafkaListener                            
    
OpenTiny Vue 3.12.0 发布：文档大优化！增加水印和二维码两个新组件                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/yang134679/article/details/136636477
                
    • 

            
        

        
    
            
      
                
    • 
                    最新文章
                
      • 
                
    • 
                    
攻防演习之三天拿下官网站群                            
      
数据安全治理学习——前期安全规划和安全管理体系建设                            
      
企业安全 | 企业内一次钓鱼演练准备过程                            
      
内网渗透测试 | Kerberos协议及其部分攻击手法                            
      
0day的产生 | 不懂代码的"代码审计"                            
      
安装scrcpy-client模块av模块异常，环境问题解决方案                            
      
leetcode hot100【LeetCode 279. 完全平方数】java实现                            
      
OpenWrt下安装Mosquitto                            
      
AnatoMask论文汇总                            
      
【AI日记】24.11.01 LangChain、openai api和github copilot                            
      
                          
                
      • 
            
    

            
      
                
    • 
                    热门文章
                
      • 
                
    • 
                    
十款代码表白小特效 一个比一个浪漫 赶紧收藏起来吧！！！                            
      
奉劝各位学弟学妹们，该打造你的技术影响力了！                            
      
五年了，我在 CSDN 的两个一百万。                            
      
Java俄罗斯方块，老程序员花了一个周末，连接中学年代！                            
      
面试官都震惊，你这网络基础可以啊！                            
      
你真的会用百度吗？我不信 — 那些不为人知的搜索引擎语法                            
      
心情不好的时候，用 Python 画棵樱花树送给自己吧                            
      
通宵一晚做出来的一款类似CS的第一人称射击游戏Demo！原来做游戏也不是很难，连憨憨学妹都学会了！                            
      
13 万字 C 语言从入门到精通保姆级教程2021 年版                            
      
10行代码集2000张美女图，Python爬虫120例，再上征途                            
      
                          
                
      • 
            
    

        
    
    




    
    
    
    

    
    
    
        
    
            
    
                
    
                    Copyright © 2022 侵权请联系2656653265@qq.com   
                    京ICP备2022015340号-1
                
    
                
    
                    正则表达式工具
                    cron表达式工具
                    密码生成工具
                
    
                
    
                    
                    
    京公网安备 11010502049817号