Java8使用Stream对集合的操作集锦

于 2023-06-01 17:02:54 发布
阅读量597 收藏
点赞数
分类专栏： Java 文章标签： list java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kongbai_java/article/details/130797860
版权

本文收集了网络上Stream流的用法和我在项目中的实际使用案例，不对其原理进行描述（俺也不会，哈哈）。
以下使用有错误、疑问或者更好的写法欢迎评论区讨论学习。
同时也欢迎各位大佬评论区留下本文中未提及的好用的api方法讨论学习。

创建业务逻辑测试实体类。

在这里插入图片描述

加入测试数据，以代码示例都以此测试数据为依据。

	public static List<User> getUserList() {
	    List<User> list = new ArrayList<>();
	    list.add(User.builder().id(1L).userName("剑帝").age(18).height(BigDecimal.valueOf(170.7)).createTime(DateUtil.parseDateTime("2023-05-21 17:17:17")).build());
	    list.add(User.builder().id(2L).userName("街霸").age(20).height(BigDecimal.valueOf(165.6)).createTime(DateUtil.parseDateTime("2023-05-20 18:17:17")).build());
	    list.add(User.builder().id(3L).userName("红眼").age(25).height(BigDecimal.valueOf(185.7)).createTime(DateUtil.parseDateTime("2023-06-21 18:17:17")).build());
	    list.add(User.builder().id(4L).userName("瞎子").age(27).height(BigDecimal.valueOf(180.5)).createTime(DateUtil.parseDateTime("2023-05-30 17:17:17")).build());
	    list.add(User.builder().id(5L).userName("枪炮师").age(23).height(BigDecimal.valueOf(175.7)).createTime(DateUtil.parseDateTime("2022-05-21 17:17:17")).build());
	
	    return list;
	}

1、去重方法

需要注意的是 distinct() 在不修改对象重写的equals和hashCode方法情况下，对象中的每个属性值必须完全相等才会被去重。
如果需要对某个属性进行去重的话可以重写equals和hashCode方法，或者使用如下写法。(这也是网上给出的普遍方法，我个人认为这个方法有一点瑕疵，就是新的数据和旧数据顺序不一致了，欢迎评论区留下更好的方法！)
【示例】在测试数据基础上新增去重的测试数据

	public static void main(String[] args) {
		// 获取测试数据
	    List<User> list = getUserList();
	    list.add(User.builder().id(7L).userName("枪炮师").age(23).height(BigDecimal.valueOf(175.7)).createTime(DateUtil.parseDateTime("2022-05-21 17:17:17")).build());
	
	//    List<User> userList = list.stream().distinct().collect(Collectors.toList());
	
	    List<User> userList = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() ->
	            new TreeSet<>(Comparator.comparing(User::getUserName))), ArrayList::new));
	    userList.forEach(System.err::println);
	
	}

运行结果：
在这里插入图片描述

2、内存分页方法

在一些复杂的业务场景下，数据库分页往往达不到需求，这时候就需要手动分页，此api还是很好的，比之前手动计算好太多了。
【示例】limit(long n) 方法用于返回前n条数据，skip(long n) 方法用于跳过前n条数据。

	public static void main(String[] args) {
		// 获取测试数据
		List<User> list = getUserList();
		
		// current为页码(当前页)，pageSize为每页显示条数，此示例是展示第二页的数据
		long current = 2; // 根据实际情况代入参数，此处仅为展示效果
		long pageSize = 3; // 根据实际情况代入参数，此处仅为展示效果
		List<User> userList = list.stream().skip((current - 1) * pageSize).limit(pageSize).collect(Collectors.toList());
		userList.forEach(System.err::println);
	}

执行结果：
在这里插入图片描述

3、过滤方法

【示例】过滤出来年龄大于20并且身高大于180的数据。（其他字段按照需求写对应的判断即可）

	public static void main(String[] args) {
		// 获取测试数据
		List<User> list = getUserList();
		
		List<User> userList = list.stream().filter(e -> e.getAge() > 20 && e.getHeight().compareTo(new BigDecimal("180")) > 0).collect(Collectors.toList());
		userList.forEach(System.err::println);
	}

执行结果：
在这里插入图片描述

4、数据处理方法

使用场景很灵活，下面仅列举了一些我使用过的场景。

4.1 map()

常用于把对象中的某个元素转换为一个新的集合。
【示例】把对象中的主键id转换为一个新的集合

	public static void main(String[] args) {
		// 获取测试数据
		List<User> list = getUserList();
		
		List<Long> idList = list.stream().map(User::getId).collect(Collectors.toList());
		idList.forEach(System.err::println);
	}

执行结果：
在这里插入图片描述

4.2 flatMap

将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流。
常用于中间数据处理。
【示例】收集对象中的属性值成为一个新的集合

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        Set<String> resultSet = list.stream().flatMap(e -> {
            HashSet<String> set = new HashSet<>();
            set.add(e.getId().toString());
            set.add(e.getAge().toString());
            return set.stream();
        }).collect(Collectors.toSet());

        resultSet.forEach(System.err::println);
    }

执行结果：
在这里插入图片描述
【示例】将map中的value处理为一个新的集合

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 造测试map，仅为测试使用，无特殊意义。
        Map<String, List<User>> map = new HashMap<>();
        map.put(list.get(0).getUserName(), list.subList(0, 2));
        map.put(list.get(1).getUserName(), list.subList(2, 4));
        map.forEach((k, v) -> System.err.println(k + "--------" + v));

        System.err.println("-----------------------------------");

        List<Integer> ageList = map.values().stream().flatMap(Collection::stream).map(User::getAge).collect(Collectors.toList());
        ageList.forEach(System.err::println);
    }

执行结果：
在这里插入图片描述

5、判断方法

【示例】

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 判断集合中是否存在年龄大于18的元素
        boolean result1 = list.stream().anyMatch(e -> e.getAge() > 18);
        // 判断集合中否存在用户名称是都包含 "剑" 的元素
        boolean result2 = list.stream().allMatch(e -> e.getUserName().contains("剑"));
        // 判断集合中是否不存在身高大于185的元素
        boolean result3 = list.stream().noneMatch(e -> e.getHeight().compareTo(new BigDecimal("185")) > 0);

        System.err.println(result1);
        System.err.println(result2);
        System.err.println(result3);
    }

执行结果：
在这里插入图片描述

6、统计方法

6.1 reduce()

【示例】使用 reduce() 求用户列表中年龄的最大值、最小值、总和。

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        Integer maxAge = list.stream().map(User::getAge).reduce(Integer::max).get();
        Integer minAge = list.stream().map(User::getAge).reduce(Integer::min).get();
        Integer sumAge = list.stream().map(User::getAge).reduce(Integer::sum).get();

        System.err.println("最大年龄：" + maxAge);
        System.err.println("最小年龄：" + minAge);
        System.err.println("年龄总和：" + sumAge);
    }

执行结果：
在这里插入图片描述

6.2 mapToInt(T -> int) 、mapToDouble(T -> double) 、mapToLong(T -> long)

int sumVal = userList.stream().map(User::getAge).reduce(0,Integer::sum)；计算元素总和的方法其中暗含了装箱成本，map(User::getAge) 方法过后流变成了 Stream 类型，而每个 Integer 都要拆箱成一个原始类型再进行 sum 方法求和，这样大大影响了效率。针对这个问题 Java 8 有良心地引入了数值流 IntStream, DoubleStream, LongStream，这种流中的元素都是原始数据类型，分别是 int，double，long。
流转换为数值流：

  • mapToInt(T -> int) : return IntStream
  • mapToDouble(T -> double) : return DoubleStream
  • mapToLong(T -> long) : return LongStream

【示例】使用 mapToInt() 求用户列表中年龄的最大值、最小值、总和、平均值。

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        int maxAge = list.stream().mapToInt(User::getAge).max().getAsInt();
        int minAge = list.stream().mapToInt(User::getAge).min().getAsInt();
        int sumAge = list.stream().mapToInt(User::getAge).sum();
        double aveAge = list.stream().mapToInt(User::getAge).average().getAsDouble();

        System.err.println("最大年龄：" + maxAge);
        System.err.println("最小年龄：" + minAge);
        System.err.println("年龄总和：" + sumAge);
        System.err.println("平均年龄：" + aveAge);

    }

执行结果：
在这里插入图片描述

3.3 counting() 和 count()

【示例】

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 统计用户名中包含 "剑" 的人数，使用 counting() 方法进行统计
        Long nameCount = list.stream().filter(user -> user.getUserName().contains("剑")).collect(Collectors.counting());

        // 统计25岁以上的人数，使用 count() 方法进行统计（推荐）
        Long ageCount = list.stream().filter(user -> user.getAge() >= 25).count();

        System.err.println("用户名中包含 '剑' 的人数：" + nameCount + "人");
        System.err.println("25岁以上的人数：" + ageCount + "人");

    }

执行结果：
在这里插入图片描述

3.4 summingInt()、summingLong()、summingDouble()

计算总和。
【示例】计算年龄总和

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 计算年龄总和（不推荐使用，idea都提示了）
        int sumAge = list.stream().collect(Collectors.summingInt(User::getAge));

        System.err.println("年龄总和：" + sumAge);

    }

执行结果：
在这里插入图片描述

3.5 averagingInt()、averagingLong()、averagingDouble()

用于计算平均值。使用方法同上，不再赘述。

3.6 summarizingInt()、summarizingLong()、summarizingDouble()

这三个方法比较特殊，比如 summarizingInt 会返回 IntSummaryStatistics 类型。
IntSummaryStatistics类提供了用于计算的平均值、总数、最大值、最小值、总和等方法，方法如下图：
在这里插入图片描述
【示例】使用 IntSummaryStatistics 统计：最大值、最小值、总和、平均值、总数。

public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 获取IntSummaryStatistics对象
        IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(User::getAge));

        // 统计：最大值、最小值、总和、平均值、总数
        System.err.println("最大年龄：" + statistics.getMax());
        System.err.println("最小年龄：" + statistics.getMin());
        System.err.println("年龄总和：" + statistics.getSum());
        System.err.println("平均年龄：" + statistics.getAverage());
        System.err.println("用户总数：" + statistics.getCount());
        
    }

执行结果：
在这里插入图片描述

3.7 BigDecimal 类型的统计

【示例】用户身高信息统计

 	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 最高身高
        BigDecimal maxHeight = list.stream().map(User::getHeight).reduce(BigDecimal::max).orElse(BigDecimal.ZERO);

        // 最低身高
        BigDecimal minHeight = list.stream().map(User::getHeight).reduce(BigDecimal::min).orElse(BigDecimal.ZERO);

        // 身高总和
        BigDecimal sumHeight = list.stream().map(User::getHeight).reduce(BigDecimal.ZERO, BigDecimal::add);

        // 平均身高
        BigDecimal avgHeight = list.stream().map(User::getHeight).reduce(BigDecimal.ZERO, BigDecimal::add).divide(new BigDecimal(list.size()));

        // 打印统计结果
        System.err.println("最高身高：" + maxHeight + "cm");
        System.err.println("最低身高：" + minHeight + "cm");
        System.err.println("身高总和：" + sumHeight + "cm");
        System.err.println("平均身高：" + avgHeight + "cm");
    }

执行结果：
在这里插入图片描述

7、排序方法

sorted() / sorted((T, T) -> int)
如果流中的元素的类实现了 Comparable 接口，即有自己的排序规则，那么可以直接调用 sorted() 方法对元素进行排序，如 Stream。反之, 需要调用 sorted((T, T) -> int) 实现 Comparator 接口。

4.1 普通排序

  • comparingInt
  • comparingLong
  • comparingDouble

【示例】使用comparingInt()对年龄进行排序

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 根据年龄排序（正序）
//        List<User> resultList = list.stream().sorted(Comparator.comparingInt(User::getAge)).collect(Collectors.toList());

        // 根据年龄排序（倒序）
        List<User> resultList = list.stream().sorted(Comparator.comparingInt(User::getAge).reversed()).collect(Collectors.toList());

        resultList.forEach(System.err::println);
    }

执行结果：
在这里插入图片描述

4.2 对时间进行排序

【示例】

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 根据创建时间排序（正序）
//        List<User> resultList = list.stream().sorted(Comparator.comparing(User::getCreateTime)).collect(Collectors.toList());

        // 根据创建时间排序（倒序）
        List<User> resultList = list.stream().sorted(Comparator.comparing(User::getCreateTime).reversed()).collect(Collectors.toList());
        
        resultList.forEach(System.err::println);
    }

执行结果：
在这里插入图片描述

4.3 对中文进行排序

此处用了 hutool拼音工具 获取中文拼音，具体使用方法可点击查看官网介绍。
【示例】

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 根据用户名称排序（正序）
//        List<User> resultList = list.stream().sorted(Comparator.comparing(User::getUserName, (x, y) -> {
//            x = PinyinUtil.getPinyin(x);
//            y = PinyinUtil.getPinyin(y);
//            Collator instance = Collator.getInstance();
//            return instance.compare(x, y);
//        })).collect(Collectors.toList());

        // 根据用户名称排序（倒序）
        List<User> resultList = list.stream().sorted(Comparator.comparing(User::getUserName, (x, y) -> {
            x = PinyinUtil.getPinyin(x);
            y = PinyinUtil.getPinyin(y);
            Collator instance = Collator.getInstance();
            return instance.compare(x, y);
        }).reversed()).collect(Collectors.toList());

        resultList.forEach(System.err::println);
    }

执行结果：
在这里插入图片描述

8、分组方法

分组这里的测试数据不太好，重新造测试数据如下：
在这里插入图片描述

5.1 普通分组

【示例】根据年龄分组

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();
        
        // 根据年龄分组
        Map<Integer, List<User>> map = list.stream().collect(Collectors.groupingBy(User::getAge));

        map.forEach((key, value) -> {
            System.err.println("年龄为："+ key + " 的数据集合：");
            value.forEach(System.err::println);
            System.err.println("--------------------------------------------------------------------------");
        });
    }

执行结果;
在这里插入图片描述

5.2 多级分组

【示例】先根据姓名分组，然后根据年龄分组

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();
        
        // 根据姓名分组，然后根据年龄分组
        Map<String, Map<Integer, List<User>>> map = list.stream().collect(Collectors.groupingBy(User::getUserName,
                Collectors.groupingBy(User::getAge)));

        map.forEach((key1, heightMap) -> {
            System.err.println(key1 + "：");
            heightMap.forEach((key2,user)-> {
                System.err.println(key2 + "：");
                user.forEach(System.err::println);
            });
            System.err.println("--------------------------------------------------------------------------");
        });
    }

执行结果：
在这里插入图片描述

5.3 分组后处理数据

下面的示例有些是我在写一些报表需求时候写的，暂时不理解没关系，遇到相应的需求时就会理解了。
【示例】根据名称分组，然后计算平均年龄

public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 根据名称分组，然后计算平均年龄
        Map<String, Double> map = list.stream().collect(Collectors.groupingBy(User::getUserName,
                Collectors.averagingInt(User::getAge)));

        map.forEach((key, value) -> {
            System.err.println(key + "的平均年龄：" + value);
        });
    }

执行结果：
在这里插入图片描述
【示例】根据姓名分组，然后去年龄最大的

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 根据姓名分组，然后去年龄最大的
        Map<String, Integer> map = list.stream().collect(Collectors.groupingBy(User::getUserName,
                Collectors.collectingAndThen(Collectors.toList(),
                        l -> l.stream().map(User::getAge).reduce(Integer::max).get())));

        map.forEach((k, v) -> {
            System.err.println("key: " + k + "-----" + "value: 最大年龄为：" + v);
        });
        
    }

执行结果：
在这里插入图片描述
【示例】先根据姓名分组，然后根据年龄分组并取第一条的身高

	public static void main(String[] args) {
        // 获取测试数据
        List<User> list = getUserList();

        // 先根据姓名分组，然后根据年龄分组并取第一条的身高
        Map<String, Map<Integer, BigDecimal>> map = list.stream().collect(
                Collectors.groupingBy(User::getUserName,
                        Collectors.groupingBy(User::getAge,
                                Collectors.mapping(User::getHeight,
                                        Collectors.collectingAndThen(Collectors.toList(), l -> l.get(0))))));

        map.forEach((key1, ageMap) -> {
            System.err.println(key1 + "：");
            ageMap.forEach((key2, height)-> {
                System.err.println(key2 + "：");
                System.err.println("身高：" + height);
            });
            System.err.println("--------------------------------------------------------------------------");
        });
    }

执行结果：
在这里插入图片描述

9、对map的简单操作

下列示例在处理字典数据的时候会用到。
【示例】转换map集合的数据类型

	public static void main(String[] args) {
        // 获取测试数据
        Map<Object, Object> map = new HashMap<>();
        map.put(1, 200.3);
        map.put(2, 500);

        Map<String, String> stringMap = map.entrySet().stream().collect(Collectors.toMap(k -> k.getKey().toString(), v -> v.getValue().toString()));

        stringMap.forEach((k, v) -> {
            System.err.println("key：" + k + "---------" + "value：" + v);
        });
        
    }

执行结果：
在这里插入图片描述
【示例】反转map的key、value

	 public static void main(String[] args) {
        // 获取测试数据
        Map<Object, Object> map = new HashMap<>();
        map.put(1, "格斗家");
        map.put(2, "鬼剑士");

        Map<String, String> reverseMap = map.entrySet().stream().collect(Collectors.toMap(k -> k.getValue().toString(), v -> v.getKey().toString()));

        reverseMap.forEach((k, v) -> {
            System.err.println("key：" + k + "---------" + "value：" + v);
        });
    }

执行结果：
在这里插入图片描述

空白Java
关注
专栏目录
JAVA8 集合操作（Stream API）
HY
04-28 351
JAVA8 集合操作（Stream API）
Java中stream流及Collectors的常见用法详细汇总！！！
最新发布
qq_45774406的博客
09-21 1761
Java中stream流及Collectors的常见用法详细汇总！！！
Java 8 Stream 操作集合
jiaomubai的博客
03-19 1419
Stream 是 Java 8 的新特性之一，它可以对集合进行非常复杂的查找、过滤、筛选等操作。Stream 也称为“流”，本文参考掘金大佬的文章：Java 8 Stream 从入门到进阶——像SQL一样玩转集合 - 掘金 通过流的定义、特征、创建过程和使用这四方面的内容，来详细了解一下 Stream 的强大。 流的定义 Java 8 引入的“流”的概念可以帮助我们更方便快捷的处理集合，不再依赖于循环遍历去处理集合，这也是 Stream 的强大之处的体现。那么，什么是“流”呢？ 官方解释是：A St.
Java8新增的Stream操作集合
FindHuni的博客
12-10 1149
1.java8新增了Stream,IntStream,LongStream等,其中Stream是一个通用的流接口.还为每个流式Api提供了对应的Builder,例如Stream.Builder,开发者可以通过这些Builder来创建对应的流.你可能要问什么是Stream？ 2.什么是Stream Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 ...
Java8 利用stream进行集合操作
学无止境
07-18 3098
下面例子中包括利用Java8 stream方式对于对象集合的分组、list转map、条件过滤、去重、排序、求和、求最大最小值。 import lombok.Data; import java.math.BigDecimal; import java.util.*; import java.util.stream.Collectors; /** * Java8 集合操作 * * @A...
java8对集合的操作
sd1209286540的博客
02-28 616
一、普通的筛选直接用list.steam().firtter() 二、如果需要去重可以调用List&lt;News&gt; addList = nowList.stream().filter( attende -&gt; sameList.stream().noneMatch(atte -&gt; attende.getUrl().equa...
Java8中利用stream对map集合进行过滤的方法
08-27
Java8中利用Stream对Map集合进行过滤的方法 Java8中引入了Stream API，提供了对集合的高效处理方式。本文将详细介绍如何使用Stream对Map集合进行过滤，包括使用filter方法过滤null和空字符串，以及使用map方法对...
Java8 Stream对两个 List 遍历匹配数据的优化处理操作
08-18
在本文中，我们将探讨如何使用Java8 Stream来对两个List进行遍历和匹配数据的优化处理操作。 首先，让我们看看两个List的数据结构。第一个List的数据结构如下： { name=张三丰1, id=1 } { name=张三丰2, id=2 } { ...
java8新特性 stream流的方式遍历集合和数组操作
08-18
Java 8 新特性 Stream 流的方式遍历集合和数组操作 Java 8 中引入了 Stream 流的概念，旨在提供一种更加优雅的方式来遍历集合和数组。Stream 流可以看作是一种 lazy 的数据结构，它可以对集合和数组进行遍历、过滤...
java使用stream对日期排序
11-17
在Java编程中，Stream API是Java 8引入的一个强大特性，它允许我们以声明性方式处理数据集合。本文将深入探讨如何使用Stream API对日期进行排序。日期排序在数据分析、日志处理、报表生成等场景中非常常见。下面我们...
java 8集合操作
wutongyuWxc的博客
02-13 4030
集合过滤、分组、去重、求和、List转Map、交集、补集、并集、差集 操作
Java8 操作集合汇总
weixin_38641763的博客
01-02 864
操作集合大全
Java8集合的一些操作
yilalong的博客
08-18 374
整理一些关于Java8集合的操作
java8 的一些基础集合操作
ailice001的博客
09-11 293
java 8 的一些使用： 1：list操作 String[] array 转 List Arrays.asList(array); List.toArray(); 2：list转map --list里的对象分组  -根据对象的元素进行分组 #### List ---&gt; Map&lt;Integer,List&lt;Object&gt;&gt;  list.stream().collec...
java8 集合学习
lswsmj的专栏
04-11 349
1.  Collection接口下的类图接口：1.       Iterabel     mplementing this interface allows an object to be the targetof the "for-each loop" statement2.      Collection 定义了一些通用的集合方法，也实现了一些jdk8才有的东西Stream ,Splitera...
Java8 对集合的操作
小菜鸟
10-10 1380
Java8 中引入了Stream流的概念，也有许多相关Stream API 提供我们使用， 通过Stream流操作集合，这样使得我们对集合的操作更加方便，对集合的操作效率会变的更高一些。 因为在以前使用的for 循环操作结合都是外部迭代，现在使用Stream流操作集合都是内部迭代，这样效率会更高。 一、 流操作的基本步骤: 1. 创建流 Stream 创建Stream的四种方式 ...
java8 集合
banheai2634的博客
07-26 174
package com.test.java.stream.collect; import static java.util.Comparator.comparingInt; import static java.util.stream.Collectors.collectingAndThen; import static java.util.stream.Collector...
Java8中Stream流对集合操作
打呼噜的星
12-24 270
之前学习了一点，无奈过了段时间还是会忘记怎么使用，然后去搜索。索性就写成实例，下次再忘记可以迅速回忆起来。 Student.java public class Student { private String name; private int age; private List<Double> grade;//四门课程成绩 private double all;//综合分数 } 初始化 List<Student> studentLis
Java8 Stream详解：简化集合操作的利器
"Java8 Stream使用教程" Java8中的Stream API是编程模型的一次重大创新，它为处理集合数据提供了一种声明性、高效且灵活的方式。Stream API的设计目标是支持序列式和并行化操作，尤其适用于大量数据处理。在Java8中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值