Java 8 Stream流的常见操作

已于 2023-01-23 23:33:01 修改
阅读量299 收藏 2
点赞数
分类专栏： Java基础 文章标签： java jvm 开发语言
于 2023-01-23 23:32:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyxxy123/article/details/128745299
版权

Stream流的使用

在 Java 8 中, 集合接口有两个方法来生成流：

stream() − 为集合创建串行流。

parallelStream() − 为集合创建并行流。

串行流

如果是数组的话，可以使用 Arrays.stream() 或者 Stream.of() 创建流；如果是集合的话，可以直接使用 stream() 方法创建流，因为该方法已经添加到 Collection 接口中。
示例1：

//集合创建流的方法
 public static void main(String[] args) {
        String[] arr = new String[]{"aaa", "bbb", "ccc"};
        Stream<String> stream = Arrays.stream(arr);
		//方法一
        stream = Stream.of("aaa", "bbb", "ccc");
        //方法二
        List<String> list = new ArrayList<>();
        list.add("xxx");
        list.add("yyy");
        list.add("zzz");
        stream = list.stream();
    }

示例2：

//Map创建流的方法
public static void main(String[] args) {
        //map获取流
        Map<Object, Object> map = new HashMap<>();
        map.put("a","111");
        map.put("b","222");
        map.put("c","333");
        map.put("d","444");
        Stream<Object> keyStream = map.keySet().stream();
        Stream<Object> valueStream = map.values().stream();
        Stream<Map.Entry<Object, Object>> entryStream = map.entrySet().stream();
        //筛选过滤  筛选出value = "111","222"的数据
        Map<Object, Object> collect = entryStream.filter(s -> "111".equals(s.getValue()) || "222".equals(s.getValue())).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        System.out.println(collect); //结果:{a=111, b=222}
    }

并行流

并行流就是将一个流的内容分成多个数据块，并用不同的线程分别处理每个不同数据块的流。
可以调用的 parallelStream() 方法。当然也可以通过 stream.parallel() 将普通流转换成并行流。并行流也能通过sequential()方法转换为顺序流，但要注意：流的并行和顺序转换不会对流本身做任何实际的变化，仅仅是打了个标记而已。并且在一条流水线上对流进行多次并行 / 顺序的转换，生效的是最后一次的方法调用。
示例：

public static void main(String[] args) {
        //1、直接获取并行流
        List<Integer> list = new ArrayList<>();
        Stream<Integer> parallelStream = list.parallelStream();
        //2、串行流转并行流
        List<Integer> list2 = new ArrayList<>();
        Stream<Integer> parallelStream2 = list2.stream().parallel();
        //3、并行流转顺序流
        Stream<Integer> sequential = parallelStream2.sequential();
    }

操作流

Stream 类提供了很多有用的操作流的方法如下：

方法作用
filter()接收lambda，从流中排除某些操作
limit()截断流，使其元素不超过给定对象
skip（n）跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流，与limit（n）互补
distinct筛选，通过流所生成元素的hashCode（）和equals去除重复元素
map接受Lambda，将元素转换成其他形式或提取信息。接受一个函数作为参数，该函数会被应用到每个元素上，并
sorted（）自然排序（Comparable）
sorted（Comparator com）定制排序（Comparator）
allMatch检查是否匹配所有元素
anyMatch检查是否至少匹配一个元素
noneMatch检查是否没有匹配所有元素
findFirst返回第一个元素
findAny返回当前流中的任意元素
count返回流中元素的总个数
max返回流中最大值
min返回流中最小值
reduce归约操作可以将流中元素反复结合起来，得到一个值
collect将流转换为其他形式，接收一个Collector接口实现，用于给Stream中汇总的方法

操作流程
1、创建一个Stream：从一个数据源，如集合、数组中获取流
2、使用Stream操作数据：一个操作的中间链，对数据源的数据进行操作
3、终止Stream：一个终止操作，执行中间操作链，并产生结果

1）过滤

示例：

public static void main(String[] args) {
        //通过 filter() 方法可以从流中筛选出我们想要的元素
        List<String> list = new ArrayList<>();
        list.add("徐凤年");
        list.add("李淳罡");
        list.add("青鸟");
        list.add("邓太阿");
        //筛选出带有“邓”的字符串。
        Stream<String> stream = list.stream().filter(s-> s.contains("邓"));
        stream.forEach(System.out::println);
    }

2）截断

示例：

public static void main(String[] args) {
        //通过 limit() 方法可以从流中截取出我们想要的元素
        List<String> list = new ArrayList<>();
        list.add("徐凤年");
        list.add("李淳罡");
        list.add("青鸟");
        list.add("邓太阿");
        //筛选出前3条数据
        list.stream().limit(3).forEach(System.out::println); 
    }

3）跳过元素

示例：

public static void main(String[] args) {
        //通过 skip() 方法可以从流中跳过某元素筛选出我们想要的元素
        List<String> list = new ArrayList<>();
        list.add("徐凤年");
        list.add("李淳罡");
        list.add("青鸟");
        list.add("邓太阿");
        //筛选出跳过"徐凤年"的list
        list.stream().skip(1).forEach(System.out::println);
    }

4）去重

示例：

 public static void main(String[] args) {
        // 通过distinct()方法去重
        List<String> stringList = new ArrayList<String>() {{
            add("A");
            add("A");
            add("B");
            add("B");
            add("C");
        }};
        stringList = stringList.stream().distinct().collect(Collectors.toList());
        System.out.println(stringList);
        //实体类列表的去重【注意:实体类需要重写equals() 以及 hashCode() 方法,否则distinct()不生效】
        List<UserInfo> userInfoList = new ArrayList<UserInfo>() {{
            add(new UserInfo("张三","18"));
            add(new UserInfo("张三","18"));
            add(new UserInfo("李四","21"));
            add(new UserInfo("王五","44"));
            add(new UserInfo("赵六","48"));
            add(new UserInfo("赵六","88"));
        }};
        userInfoList = userInfoList.stream().distinct().collect(Collectors.toList());
        System.out.println("userInfoList:"+userInfoList);
        //根据 List<Object> 中 Object 某个属性去重【指定属性去重】
        List<UserInfo> userInfoList2 = userInfoList.stream().collect(
                collectingAndThen(
                        toCollection(() -> new TreeSet<>(Comparator.comparing(UserInfo::getUserName))), ArrayList::new)
        );
        System.out.println("userInfoList2:"+userInfoList2);
    }

5）映射

示例：

 public static void main(String[] args) {
        //map()方法指定映射
        List<String> list = new ArrayList<>();
        list.add("徐凤年");
        list.add("李淳罡");
        list.add("青鸟");
        list.add("邓太阿");
        Stream<Integer> stream = list.stream().map(String::length);
        stream.forEach(System.out::println); //结果 3 3 2 3
    }

6）排序

示例：

 public static void main(String[] args) {
        //sorted()方法 实体类列表的排序
        List<UserInfo> userInfoList = new ArrayList<UserInfo>() {{
            add(new UserInfo("张三", "18"));
            add(new UserInfo("李四", "21"));
            add(new UserInfo("王五", "66"));
            add(new UserInfo("赵六", "16"));
            add(new UserInfo("赵六", "88"));
        }};
        //升序排序
        userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList());
        //降序排序  reversed()
        userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()).collect(Collectors.toList());
    }

7）匹配

示例：

 public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("徐凤年");
        list.add("李淳罡");
        list.add("青鸟");
        list.add("邓太阿");
		//anyMatch：判断的条件里，任意一个元素成功，返回true
        boolean  anyMatchFlag = list.stream().anyMatch(s-> s.contains("徐"));
        //allMatch：判断条件里的元素，所有的都是，返回true
        boolean  allMatchFlag = list.stream().allMatch(s-> s.length() > 1);
        //noneMatch：与allMatch相反，判断条件里的元素，所有的都不是，返回true
        boolean  noneMatchFlag = list.stream().noneMatch(s -> s.endsWith("李"));
        System.out.println(anyMatchFlag);
        System.out.println(allMatchFlag);
        System.out.println(noneMatchFlag);
    }

8）返回第一个元素

示例：

public static void main(String[] args) {
        //findFirst()方法 返回列表中的第一个元素
        List<String> list = Arrays.asList("C", "C++", "JAVA", "Python","JON","COM");
        Optional<String> first = list.parallelStream().filter(s -> s.startsWith("C")).findFirst();
        //findAny()方法，返回的元素是不确定的
        Optional<String> findAny = list.parallelStream().filter(s -> s.startsWith("C")).findAny();
        System.out.println("first:"+first);
        System.out.println("findAny:"+findAny);
    }

9）返回流中的任意元素

示例：

public static void main(String[] args) {
        //findAny()方法 返回任意一条数据
        List<UserInfo> userInfoList = new ArrayList<UserInfo>() {{
            add(new UserInfo("张三","18"));
            add(new UserInfo("李四","21"));
            add(new UserInfo("王五","44"));
            add(new UserInfo("赵六","48"));
        }};
        //筛选出"王五"的数据,返回实体,orElse (null)表示如果一个都没找到返回null【orElse ()中可以塞默认值。】
        UserInfo userInfo = userInfoList.stream().filter(s->"王五".equals(s.getUserName())).findAny().orElse(null);
        System.out.println(userInfo);
    }

10）聚合函数

示例：

public static void main(String[] args) {
        //count()方法 统计元素总数
        List<String> list = Arrays.asList("AAA", "BBB", "CCC", "DDD");
        long count = list.stream().count();
        System.out.println("count:" + count); //结果 count:4
        //max()最大值
        List<Integer> maxList = Arrays.asList(10, 20, 30, 40);
        Optional<Integer> maxOptional = maxList.stream().max(Comparator.comparing(Function.identity()));
        System.out.println("max:"+maxOptional.get()); //结果 max:40
        //min()最小值
        List<Integer> minList = Arrays.asList(10, 20, 30, 40);
        Optional<Integer> maxOptional2 = minList.stream().min(Comparator.comparing(Function.identity()));
        System.out.println("min:"+maxOptional2.get());//结果 min:10
    }

11）归约操作

``
示例：

public static void main(String[] args) {
        //reduce()方法 归约操作
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        // 方法一
        int sum = Arrays.stream(numbers).reduce(0, (a, b) -> a + b);// 55
        //方法二
        int sum2 = Arrays.stream(numbers).reduce(0, Integer::sum);// 55
        //数学运算
        int sum3 = Arrays.stream(numbers).reduce(0, (a, b) -> a - b);// -55
        int sum4 = Arrays.stream(numbers).reduce(0, (a, b) -> a * b);// 0
        int sum5 = Arrays.stream(numbers).reduce(0, (a, b) -> a / b); // 0
        //最大和最小
        int max = Arrays.stream(numbers).reduce(0, (a, b) -> a > b ? a : b);  // 10
        int max1 = Arrays.stream(numbers).reduce(0, Integer::max);            // 10

        int min = Arrays.stream(numbers).reduce(0, (a, b) -> a < b ? a : b);  // 0
        int min1 = Arrays.stream(numbers).reduce(0, Integer::min);            // 0
    }

11）规约操作

将流转换为其他形式，接收一个Collector接口实现，用于给Stream中汇总的方法
示例：

public static void main(String[] args) {
        //collect()方法 将流转换为其他形式，接收一个Collector接口实现，用于给Stream中汇总的方法
        String[] strings = {"AAA", "BBB", "CCC", "DDD"};
        //Collectors.toList() 收集元素到List集合
        List<String> collectList = Arrays.stream(strings).collect(Collectors.toList());
        //Collectors.toSet() 收集元素到set集合
        Set<String> collectSet = Arrays.stream(strings).collect(Collectors.toSet());
        //Collectors.toMap(String::toString,o->o) 收集元素到map集合
        Map<String, Object> collectMap =Arrays.stream(strings).collect(Collectors.toMap(String::toString,o->o));
        //Collectors.toCollection()  收集元素到指定集合
        ArrayList<String> arrayList = Arrays.stream(strings).collect(Collectors.toCollection(ArrayList::new));
    }

注意：记录stream流的一些常用的操作方法(●'◡'●)

青衫逍遥客
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8——Stream流详解
weixin_44863459的博客
08-27 2149
Stream
Java8 常用的Stream流操作
Ztw_bb的博客
09-13 294
概念：Steam 是Java8 提出的一个新概念，不是输入输出的 Stream 流，而是一种用函数式编程方式在集合类上进行复杂操作的工具。简而言之，是以内部迭代的方式处理集合数据的操作，内部迭代可以将更多的控制权交给集合类。Stream 和 Iterator 的功能类似，只是 Iterator 是以外部迭代的形式处理集合数据的操作。 在Java8以前，对集合的操作需要写出处理的过程，如在集合中筛选出满足条件的数据，需要一 一遍历集合中的每个元素，再把每个元素逐一判断是否满足条件，最后将满足条件的元素保存返
java8 stream操作
小猿的博客
08-29 125
原文链接： https://www.jianshu.com/p/11c925cdba50 相信Java8的Stream 大家都已听说过了，但是可能大家不会用或者用的不熟，笔者将在《玩转Java8Stream》系列文章中带大家从零开始使用，循序渐进，带你走向Stream的巅峰。 操作符 什么是操作符呢？操作符就是对数据进行的一种处理工作，一道加工程序；就好像工厂的工人对流水线上的产品进行一道加工程序一样。 image-20190124191452884 Stream的操作符大体上分为两种：中间操作符和终止操作
count 详细解析 Java 8 Stream API 中的 count 方法
最新发布
一名资深Java工程师的技术分享
07-01 1433
count 是 Stream 接口中的一个终端操作（terminal operation），它用于返回 Stream 中的元素个数。
java8 stream常用方法
热门推荐
lockie的博客
05-20 3万+
一. 什么是 Stream Stream 中文称为“流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。 二. 流操作 整个流操作就是一条流水线，将元素放在流水线上一个个地进行处理。 其中数据源便是原始集合，然后将如 List<T> 的集合转换为 Stream<T> 类型的流，并对流进...
Java 8 新特性之流—Stream 操作总结（持续更新）
来到人间不过是个蹭饭的客人，还挑什么酸甜苦辣。
01-15 2861
在我们开发中，经常会对集合进行过滤映射去重排序聚合统计遍历归集分组拼接等常用操作，为了写出高效率、干净、简洁的代码，Java 8 API 提供了流 Stream API 来进行处理。
Java1.8 Stream流常用操作
System_Gu的博客
04-15 1034
1、排序 result = result.stream().sorted(Comparator.comparing(QueryRecordListVO::getUseTime,Comparator.nullsFirst(String::compareTo)).reversed()).collect(Collectors.toList()); //倒序 result = result.stream().sorted(Comparator.comparing(QueryRecordListVO::getUseT
Java8 Stream流的三个步骤操作.docx
07-10
在Java 8中，Stream API引入了一种新的处理数据的方式，它允许我们以声明性风格对集合、数组等数据源进行高效的操作。Stream是数据渠道，它可以用来处理一系列元素，如从集合或数组中生成的元素序列。Stream操作通常...
Java8 Stream API 详细使用方法与操作技巧指南
08-19
Java8 Stream API 详细使用方法与操作技巧指南 Java 8 引入了 Stream API，这是一个重要的特性，允许开发者以一种声明式的方式对数据进行处理。Stream 翻译过来是“流”，它可以看做是一个可操作的数据集序列，具有...
JAVA JDK8新概念Stream流及操作集合案例
12-22
在Java 8中，Stream流常用于集合数据的过滤、映射、排序等操作。例如，以下代码演示了如何使用Stream流过滤出以"张"开头并且长度为3的名字： ```java List<String> list = Arrays.asList("张三", "李四", "王五...
JAVA-Stream流详解
分享，学习，专注，努力，向上。
07-02 3329
Stream（流）是Java 8引入的新特性，它是一种处理集合数据的高级抽象概念。Stream流提供了一种更为简洁、强大和易于使用的方式来操作数据集合，可以进行过滤、映射、排序、聚合等各种操作，同时还支持并行处理，提高了代码的可读性和性能。
java 8 stream 常用操作
tyrroo的博客
07-16 609
生成 Stream Source有多种方式： 从 Collection 和数组 Collection.stream() Collection.parallelStream() Arrays.stream(T array) or Stream.of() 从 BufferedReader java.io.BufferedReader.lines() 静态工厂 java.ut...
java8 Stream的常用操作
m0_52283512的博客
09-15 297
java8 stream流的常用操作示例
JAVA8 stream操作
LILAIQUN博客
09-24 120
原始数据 id vid sid 1 1 3001 2 1 3002 3 1 3003 4 3 4001 5 3 4002 6 3 4003 class Row { Integer id, Long vid, Long sid } // 1.查询vid=1，返回所有sid列表 list.stream().map(Row::getVid).collect(Colle.
Java8之Stream操作
Dormiveglia-flx的博客
05-12 798
终结操作常用的是foreach、collect、reduce。中间操作常用的是 filter、map、flatmap。Stream 就是操作数据用的。创建流 → 中间操作 → 终结操作。
java8 stream 操作
neweastsun的专栏
10-31 1440
java8流教程，结合代码，简明好懂。
java8_stream操作
dream_on_sakura_rain
08-23 248
import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.stream.Collectors; /** * @author licunzhi * @desc 描...
java8 stream流 常见api
03-16
Java 8 中的 Stream API 提供了许多有用的方法来处理集合数据。常见的 API 包括： - filter()：过滤元素 - map()：将元素映射成另一种元素 - limit()：限制流中元素的数量 - sorted()：按照顺序对元素进行排序 - forEach()：对流中的每个元素进行操作 - collect()：将流转换为集合或其他容器 - reduce()：对流中的元素进行归纳操作 这只是 Stream API 中的一些常用方法，还有许多其他有用的方法可供使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值