java8之Stream流

🕗 发布于 2024-11-17 00:13 java 后端

文章目录

Stream流的定义和特性‌
生成流
forEach
map
filter
limit
sorted
并行（parallel）程序
Collectors

Stream流的定义和特性‌

定义

Stream是Java 8 API添加的一个新的抽象，用于以声明性方式处理数据集合。它不是一种数据结构，而是某种数据源的一个视图，支持序列与并行两种操作方式‌3。‌

特性‌

Stream流的操作是惰性的，只有在需要结果时才会执行。这使得Stream流在处理大量数据时更加高效。此外，Stream流与Lambda表达式结合使用，可以提高编程效率、间接性和程序可读性‌。
‌Stream流的常见操作‌：‌

中间操作‌

包括过滤（filter）、排序（sorted）、截取（limit）、跳过（skip）等，用于打开流并处理数据，生成新的流‌。

终结操作‌

如forEach()、collect()等，用于最终获取结果。终结操作执行后，流无法再进行操作‌。

生成流

通过集合生成‌：对于Collection体系的集合，可以使用默认方法stream()生成流。例如，对于List、Set等集合，可以直接调用它们的stream()方法生成流‌12。
通过数组生成‌：数组可以通过Arrays类的静态方法stream()生成流。例如，对于String[] strArray数组，可以使用Arrays.stream(strArray)生成流‌。
通过Stream接口的静态方法生成‌：对于同种数据类型的多个数据，可以通过Stream接口的静态方法of()生成流。例如，Stream.of(“hello”, “world”, “java”)可以生成包含这些字符串的流‌

forEach

Stream 提供了新的方法 ‘forEach’ 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数：

Random random = new Random();
//输出随机数
random.ints().limit(10).forEach(System.out::println);
//forEach进行操作

map

map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList()); // 获取对应的平方数

filter

filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

long count = strings.stream().filter(string -> string.isEmpty()).count(); // 获取空字符串的数量

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

limit

limit 方法用于获取指定数量的流。以下代码片段使用 limit 方法打印出 10 条数据：

Random random = new Random();

random.ints().limit(10).forEach(System.out::println);

sorted

sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：

Random random = new Random();

random.ints().limit(10).sorted().forEach(System.out::println);

并行（parallel）程序

parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

我们可以很容易的在顺序运行和并行直接切换。

Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

System.out.println("筛选列表: " + filtered);

String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));

System.out.println("合并字符串: " + mergedString);

示例：

package main.java;

import javax.swing.*;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Administrator
 */
public class StreamTest {
    public static void main(String[] args) {
        System.out.println("使用java7");
        List<String> strList = Arrays.asList("AAA","","BBB","","CCC","DDDDD","","EEEE","","FFFFFF");
        System.out.println("strList列表："+strList.toString());
        //计算空字符串个数
        long count = calculateEmptyStr(strList);
        System.out.println("strList列表空字符串个数："+count);

        //计算字符串长度=3的个数
        count = calculateStrLengthEqual3(strList);
        System.out.println("strList列表字符串长度为3的个数："+count);

        //删除空字符串
        List<String> str1List = deleteEmptyStr(strList);
        System.out.println("strList列表去除空字符串的列表为："+ str1List.toString());

        //拼接字符串
        String str1 = deleteEmptyAndJoinStr(strList,",");
        System.out.println("strList列表拼接字符串："+str1);

        List<Integer> intList = Arrays.asList(3,4,5,6,7,8,9,10);
        System.out.println("intList列表为："+intList);
        //计算列表元素平方数
        List<Integer> int2List = getIntegerSquares(intList);
        System.out.println("intList的平方数列表为："+int2List);

        List<Integer> int1List = Arrays.asList(2,5,6,7,3,8,1,11,22,25,18);
        //计算最大数，最小数，平均数，所有数之和
        System.out.println("int1List列表："+int1List);
        System.out.println("int1List列表的最大数:" + getIntegerListMax(int1List));
        System.out.println("int1List列表的最小数：" + getIntegerListMin(int1List));
        System.out.println("int1List列表的所有数之和："+ getListSum(int1List));
        System.out.println("int1List列表的平均数：" + getAverage(int1List));
        //输出10个随机数
        Random random = new Random();
        for (int i = 0; i < 10 ; i++) {
            System.out.println(random.nextInt());
        }

        System.out.println("使用java8:");
        System.out.println("strList列表："+ strList.toString());
        System.out.println("strList列表空字符串个数："+ strList.stream().filter(string -> string.isEmpty()).count());
        System.out.println("strList列表字符串长度为3的个数："+ strList.stream().filter(string -> string.length() == 3).count());
        System.out.println("strList列表去除空字符串的列表为："+ strList.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()));
        System.out.println("strList列表拼接字符串："+ strList.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(",")));
        System.out.println("intList列表为："+ intList);
        System.out.println("intList的平方数列表为："+ intList.stream().map(i -> i*i).distinct().collect(Collectors.toList()));
        System.out.println("int1List列表："+int1List);
        IntSummaryStatistics statistics = int1List.stream().mapToInt((x) -> x).summaryStatistics();
        System.out.println("int1List列表的最大数:" + statistics.getMax());
        System.out.println("int1List列表的最小数：" + statistics.getMin());
        System.out.println("int1List列表的所有数之和："+ statistics.getSum());
        System.out.println("int1List列表的平均数：" + statistics.getAverage());
        //输出十个随机数
        random.ints().limit(10).sorted().forEach(System.out::println);

    }

    private static Integer getListSum(List<Integer> int1List) {
        Integer result = 0;
        for (Integer integer : int1List) {
            result += integer;
        }
        return result;
    }

    private static Integer getAverage(List<Integer> int1List) {
        Integer result = 0;
        Integer sum = 0;
        for (Integer integer : int1List) {
            sum += integer;
        }
        result = sum/int1List.size();
        return result;
    }

    private static Integer getIntegerListMax(List<Integer> int1List) {
        int max = int1List.get(0);
        for (int i = 1;i<int1List.size();i++){
            if(max <= int1List.get(i)){
                max = int1List.get(i);
            }
        }
        return max;
    }

    private static Integer getIntegerListMin(List<Integer> int1List) {
        int min = int1List.get(0);
        for (int i = 1;i<int1List.size();i++){
            if(min >= int1List.get(i)){
                min = int1List.get(i);
            }
        }
        return min;
    }

    private static List<Integer> getIntegerSquares(List<Integer> intList) {
        List<Integer> resultList = new ArrayList<Integer>();
        for (Integer integer : intList) {
            integer *= integer;
            resultList.add(integer);
        }
        return resultList;
    }

    private static String deleteEmptyAndJoinStr(List<String> str1List,String separator) {
        StringBuilder resultStr = new StringBuilder();
        for (String s : str1List) {
            if (!s.isEmpty()){
                resultStr.append(s);
                resultStr.append(separator);
            }
        }
        return resultStr.substring(0,resultStr.length()-2);
    }

    private static List<String> deleteEmptyStr(List<String> strList) {
        List<String> result = new ArrayList<String>();
        for (String s : strList) {
            if (!s.isEmpty()){
                result.add(s);
            }
        }
        return result;
    }

    private static long calculateStrLengthEqual3(List<String> strList) {
        long result = 0;
        for (String s : strList) {
            if (s.length() == 3){
                result += 1;
            }
        }
        return result;
    }

    private static long calculateEmptyStr(List<String> strList) {
        long result = 0;
        for (String s : strList) {
            if (s.isEmpty()){
                result += 1;
            }
        }
        return result;
    }
}

原文地址：https://blog.csdn.net/weixin_45146962/article/details/143700043

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Bag Graph: Multiple Instance Learning Using Bayesian Graph Neural Networks文献笔记
下一篇：【NLP】第一章：知识体系框架概览

预处理（1）（手绘）
大家好，今天给大家分享一下编译器预处理阶段，那么我们来看看。上面是一些预处理阶段的知识，那么明天给大家讲讲宏吧。
阅读更多2024-11-18
C语言项⽬实践-贪吃蛇
GetAsyncKeyState 的返回值是short类型，在上⼀次调⽤ GetAsyncKeyState 函数后，如果返回的16位的short数据中，最⾼位是1，说明按键的状态是按下，如果最⾼是0
阅读更多2024-11-18
Cache Line设计
以上代码实现了模拟的 Cache Line 结构，并包含了初始化、修改和释放内存的功能，完全符合题目中的需求描述。
阅读更多2024-11-18
Linux性能优化之火焰图简介
Linux 火焰图（Flame Graph）是一种可视化工具，用于分析程序性能问题，尤其是 CPU 使用情况。它展示了程序中函数调用的层次结构和各个调用栈占用的时间比例。本文详细介绍，包括火焰图的工作
阅读更多2024-11-18
南京邮电大学《智能控制技术》期末抢救（下）
专家系统是一个智能程序系统：具有相关领域内大量的专家知识；能应用人工智能技术模拟人类专家求解问题的思维过程进行推理，解决相关领域内的困难问题，并且达到领域专家的水平。专家系统所要解决的问题一般没有算法
阅读更多2024-11-18
pytorch基础-前向传播与反向传播
神经网络的基础，前向传播与反向传播（包含理论推导与pytorch代码）
阅读更多2024-11-18
【hacker送书第15期】AI绘画精讲与AIGC时代游戏美术设计：从入门到精通
随着人工智能技术的飞速发展，AI绘画已经成为了一个备受瞩目的领域。在这个背景下，北京大学出版社推出了一系列关于AI绘画的优秀图书，其中就包括了《AI绘画精讲：Stable Diffusion从入门到精
阅读更多2024-11-18
Electron：Menu 自定义菜单的使用、自定义右键菜单、动态创建菜单
Electron：Menu 自定义菜单的使用、自定义右键菜单、动态创建菜单
阅读更多2024-11-18
算法----二分法找出有序列表指定值
res = dichotomy(0, len(data) - 1, data, 56) # 这里max索引应该是len(data) - 1，因为索引从0开始。return dichotomy(mid
阅读更多2024-11-18
网络
第四次挥手时，客户端发出 ACK 后，会等待 2MSL（报文在网络上存在的最长时间）确保最后的 ACK 报文能够到达服务端，2MSL 之后客户端会关闭连接，服务端收到确认后也会关闭连接。IP 协议是整
阅读更多2024-11-18