(超级详细)JAVA之Stream流分析-------持续更新喔！！！

最新推荐文章于 2024-06-21 22:23:19 发布
最新推荐文章于 2024-06-21 22:23:19 发布
阅读量1.7k 收藏 31
点赞数 55
分类专栏： java基础 文章标签： java 开发语言 后端 maven log4j tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aoyuanyuan0921/article/details/138092785
版权

学习目标：

  • 掌握 Java Stream流的相关api
  • 掌握 Java Stream流的基本实现
  • 掌握 java Stream流的使用场景
  • 代码已经整理上传到了gitee中，有需要的小伙伴可以取查看一下源码点个小心心喔

大家也可以帮我提交一点案例喔！！！！！
大家一起交流学习！
https://gitee.com/Aoyuan-210902/JAVAStreamDemo.git

点个赞嘛！！！！！！！！！！！！！！！！！！！！！！！！！
在这里插入图片描述

JAVA Stream流

概述

Java Stream API 是 Java 8 中引入的一个功能强大的新库，它提供了一种高效且声明式的处理数据集合的方法。通过使用 Streams，开发者可以写出简洁且易于理解的代码，用于对数据执行复杂的查询和聚合操作。

什么是Stream流，Stream流的特点是什么？

  • 含义
    在 Java 中，Stream 是对集合（Collection）对象功能的一个补充，它支持顺序和并行的聚集操作。Streams 不存储数据，它们只在需要时从源（如集合或数组）中获取数据。

  • 主要特点
    声明式：相比于传统的迭代方式，stream 提供了一种声明式的方法来表达数据处理任务。
    可组合：stream 操作可以链接起来，形成一个大的流水线，这样可以表达复杂的数据处理策略（比如筛选，排序等）。
    并行能力：Streams 可以透明地并行处理，利用多核架构而无需编写特定的多线程代码。

常见操作

Stream 操作分为中间操作和终端操作两种：

中间操作：如 filter、map、sorted 等，它们返回一个新的 Stream，可以连接多个中间操作。
终端操作：如 forEach、collect、reduce 等，它们输出结果或者产生副作用（例如输出到屏幕），并且关闭 Stream。

一些Stream的特性

  • 函数式编程： 通过Stream流可以代替复繁琐难懂的for循环等代码，对数据进行操作。
  • Stream流不会直接得出结果，而是在调用终端操作的时候，才会运行中间操作。

Optional类

在Java中，Optional是一个容器类，它可以包含也可以不包含非空值。Optional类主要用于防止NullPointerException异常的发生，它提供了一种更优雅的方法来处理可能为null的对象。使用Optional可以显式地要求调用者处理空值情况。

Optional提供了多种方法来检查、获取和转换包含的值：

isPresent()：检查Optional是否有值。
get()：获取Optional的值，如果Optional为空，则抛出NoSuchElementException。
orElse()：如果Optional有值则返回该值，否则返回传递给orElse的参数。
ifPresent()：如果值存在，执行给定的操作。 map()和flatMap()：对Optional的值应用函数。
Optional常用于新的Java API中，如Stream的终端操作，返回一个Optional类型的结果

。

Stream流的操作

distinct

package distinctStream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class DistincrtStrream {
    public static void main(String[] args) {
        //distint主要是去除掉集合中重复的代码
        List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6);
        List<Integer> collect = list.stream().distinct().collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
}
运行实例

在这里插入图片描述

filter筛选操作

示例1

package filterStream;

import java.util.ArrayList;
import java.util.List;

public class FilterDemo01 {
    //找到集合中元素大于5的数
    public static void main(String[] args) {
        List<Integer> demo01 = new ArrayList<>();
        demo01.add(1);
        demo01.add(5);
        demo01.add(7);
        demo01.add(8);
        demo01.add(9);
        System.out.println("没有进行筛选之前的数据");

        demo01.forEach(System.out::println);
        System.out.println("筛选之后的数据");
        demo01.stream().filter(x -> x > 5).forEach(System.out::println);
    }
}

在这里插入图片描述
示例2

package filterStream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class FilterDemo02 {
    public String username;
    public String password;

    public FilterDemo02() {
    }

    public FilterDemo02(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "FilterDemo02{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public static void main(String[] args) {
        FilterDemo02 user01 = new FilterDemo02("aoyuan","123");
        FilterDemo02 user02 = new FilterDemo02("yuan","234");
        FilterDemo02 user03 = new FilterDemo02("ao","345");

        List<FilterDemo02> list  = new ArrayList<>();
        list.add(user01);
        list.add(user02);
        list.add(user03);
        //查找username = aoyuan的
        List<FilterDemo02> collect = list.stream().filter(n -> n.getUsername().equals("aoyuan")).collect(Collectors.toList());
        collect.forEach(System.out::println);
                System.out.println("------------------------------------------------------------------------------");

         //查找username =ao
         List<FilterDemo02> collect01 = list.stream().filter(n -> n.getUsername().equals("ao")).collect(Collectors.toList());
         collect01.forEach(System.out::println);
        System.out.println("------------------------------------------------------------------------------");
         List<FilterDemo02> collect02 = list.stream().filter(n -> n.getPassword() != "123").collect(Collectors.toList());
         collect02.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述

limit截取操作

示例1

package limitStream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class LimitDemo01 {
    public static void main(String[] args) {
        //limit是截取第n个元素
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        Stream<Integer> limit1 = list.stream().limit(2);
        Stream<Integer> limit2 = list.stream().limit(6);
        System.out.println("----------------截取第2个---------------");
        limit1.forEach(System.out::println);
        System.out.println("-----------------截取6个---------------------");
        limit2.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述
示例2

package limitStream;

import java.util.stream.Stream;

public class LimitDemo02 {
    public static void main(String[] args) {
        //interage迭代器会一直进行下去，所以由inerate创建的流是无限流，需要limit方法截断
        Stream<Integer> demo03 = Stream.iterate(0, n -> n+2).limit(6);
        demo03.forEach(System.out::println);
        System.out.println("limit起到了什么作用呢？起到了截断的作用");
        Stream<Integer>  demo04 = Stream.iterate(0,n -> n+2).limit(7);
        demo04.forEach(System.out::println);
        System.out.println("generate方法");
        //generate方法
        Stream<Double> generateStream = Stream.generate(Math::random).limit(5);
        generateStream.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述

map映射操作

User类

package mapStream;

public class User {
    private String username;
    private Integer id;
    private String address;

    public User() {
    }

    public User(String username, Integer id, String address) {
        this.username = username;
        this.id = id;
        this.address = address;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", id=" + id +
                ", address='" + address + '\'' +
                '}';
    }
}

userdao类

package mapStream;

public class UserDao {
    private String username;
    private String address;

    public UserDao() {
    }

    public UserDao(String username, String address) {
        this.username = username;
        this.address = address;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "UserDao{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

示例1

package mapStream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class FilterDemo01 {
    public static void main(String[] args) {

        List<User>  userList= new ArrayList<>();
        userList.add(new User("aoyuan",1,"baotou"));
        userList.add(new User("aoyuan01",2,"bao"));
        userList.add(new User("aoyuan02",3,"tou"));
        //拿到用户集合中的数据并将用户名转化为大写
        List<String> collect = userList.stream().map(x -> x.getUsername().toUpperCase()).collect(Collectors.toList());
        collect.forEach(System.out::println);
       //拿到user集合选择数据存储在新的userDao集合中
        List<UserDao> collect1 = userList.stream().map(x -> {
            UserDao userDao = new UserDao();
            userDao.setUsername(x.getUsername());
            userDao.setAddress(x.getAddress());
            return userDao;
        }).collect(Collectors.toList());
        collect1.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述
示例2

package mapStream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterDmeo02 {
    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> collect = list.stream().map(x -> x + 3).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }



}
运行示例

在这里插入图片描述

取max和min的相关操作

示例1

package maxStream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Demo {
    public static void main(String[] args) {
        //自定义排序
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        //从大到小排序
        Optional<Integer> max = list.stream().max((o1, o2) -> o1 - o2);
        System.out.println("最大值为+"+ max.get());

    }
}

运行示例

在这里插入图片描述

示例2

package maxStream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class Demo01 {
    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Optional<Integer> max = list.stream().max(Integer::compareTo);
        System.out.println("最大值为+："+ max);



    }
}

运行示例

在这里插入图片描述

示例3

package maxStream;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

public class Demo02 {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("aoyuan", "aoyuanao", "aoyuanaoyuan");
        Optional<String> max = strings.stream().max(Comparator.comparing(String::length));
        System.out.println("最长的字符串为" + max);
    }



}

运行示例

在这里插入图片描述
示例3

package minStream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class StreamMinExample01 {
    static class Person {
        String name;
        int age;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        int getAge() {
            return age;
        }

        @Override
        public String toString() {
            return name + ": " + age;
        }
    }

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 22),
                new Person("Bob", 20),
                new Person("Charlie", 30),
                new Person("David", 25)
        );


        Optional<Person> youngest = people.stream().min((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()));


        youngest.ifPresent(person -> System.out.println("The youngest person is " + person));
    }
}

运行示例

在这里插入图片描述

示例4

package minStream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class StreamMinExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, -1, 6, 7);

        // Using Stream.min() to find the minimum value in the list
        Optional<Integer> minNumber = numbers.stream()
                .min(Integer::compare);

        // Checking and displaying the minimum number
        if (minNumber.isPresent()) {
            System.out.println("The minimum number is " + minNumber.get());
        } else {
            System.out.println("List is empty.");
        }
    }
}

运行示例

在这里插入图片描述

reduce归约

package reduce;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class ReduceStreamDemo {

    public static void main(String[] args) {
        List<Integer> demo = new ArrayList<>();
        demo.add(2);
        demo.add(4);
        demo.add(1);
        demo.add(5);
//x+y的和
        Optional<Integer> reduce = demo.stream().reduce((x, y) -> x + y);
        System.out.println(reduce.get());
        //求最大值
        Optional<Integer> reduce1 = demo.stream().reduce((x, y) -> x > y ? x : y);
        System.out.println(reduce1.get());

    }
}
运行示例

在这里插入图片描述

排序

示例1

package sortStream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamSortExample {
    static class Person {
        String name;
        int age;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        String getName() {
            return name;
        }

        @Override
        public String toString() {
            return name + ": " + age;
        }
    }

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 22),
                new Person("Charlie", 30),
                new Person("David", 25),
                new Person("Bob", 20)
        );


        List<Person> sortedPeople = people.stream()
                .sorted((p1, p2) -> p1.getName().compareTo(p2.getName()))
                .collect(Collectors.toList());

                sortedPeople.forEach(System.out::println);



    }
}
运行示例

在这里插入图片描述

示例2

package sortStream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamSortExample02 {
    static class Person {
        String name;
        int age;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        int getAge() {
            return age;
        }

        public String getName() {
            return name;
        }

        @Override
        public String toString() {
            return name + ": " + age;
        }
    }

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 22),
                new Person("Charlie", 30),
                new Person("David", 25),
                new Person("Bob", 20)
        );

        // Sorting people by age using Stream
        List<Person> sortedByAge = people.stream()
                //自然排序
                .sorted((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()))
                .collect(Collectors.toList());

        // Displaying the sorted list
        sortedByAge.forEach(System.out::println);
        System.out.println("------------------自定义排序--------------");
        //先根据年龄再根据姓名排序
        List<Person> collect = people.stream().sorted((p1, p2) -> {
            if (p1.getAge() == p2.getAge()) {
                return p1.getName().compareTo(p2.getName());
            } else {
                return p2.getAge() - p1.getAge();
            }

        }).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述

总结

作用场景

Java Stream API 是用于处理集合和数据库的理想选择，它能够执行如排序、过滤或映射数据等聚合操作。Stream 支持并行处理，使得它能够有效地处理大型数据集。此外，Stream 在处理数据序列时能增强代码的可读性和减少样板代码，使编程更加表达和简洁。它在 Java 中的函数式编程模式中尤为有价值，帮助以声明方式操作集合。

优势和不足

优势
  1. 提高代码可读性和简洁性：通过流式表达式，可以用更少的代码完成复杂的集合处理，使代码更易于理解和维护。
  2. 支持并行处理：Stream API 设计支持并行执行，可以很容易地对数据进行并行处理，提高处理效率，尤其适用于处理大数据量。
  3. 函数式编程：支持函数式编程风格，有助于减少副作用，使程序更加稳定。
不足
  1. 性能开销：相对于传统的 for-loop，Stream 操作可能引入更多的性能开销，尤其是在小数据量或高性能场景中。
  2. 学习曲线：对于初学者，Stream API 的一些操作和概念可能比较难以理解，需要一定的学习投入。
  3. 调试困难：由于 Stream 操作的链式结构，调试可能比较复杂，特别是在流水线操作中定位问题可能比较困难。
aoyuanyuan0921
关注
  • 55
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
twitch-stream-recorder:实时记录抽搐流！
05-25
Ancalentari Twitch流记录器 此脚本使您可以将抽搐流实时记录到.mp4文件中。 它是的改进版本，已迁移到新的twitch API。 它使用OAuth2。 要求 或更高 配置 检查您是否具有最新版本的流链接： streamlink --version...
Stream-Video-Downloader-9.2.12.rar
09-01
Stream-Video-Downloader-9.2.12
第一个基于Spring-Boot框架的项目以及Java8新特新之stream流操作的简单细说
Appleyk的专栏
12-01 1万+
真是好久没有更博了，更博的初衷就是记录工作和学习中的点滴，长期积累，也算是一种资源财富的投资，想着是心里怪美的，但是真要是坚持下来，确实是一个不小的挑战。         进入新环境已经半个月了，接触了全新的项目，基于gis系统的研发。一开始真是云里雾里，后来博主那叫一个不放弃啊，每天都在问、都在自己摸索，用了一周的时间熟悉项目的数据架构和组织架构，又用了一周的时间熟悉业务，这个业务的熟
【Java基础教程】（一）入门介绍篇 · 上：快速掌握核心概念，开启Java世界的探索之旅！这篇Java入门宝典助你翱翔~
热门推荐
Technology changes the world of life
07-04 3万+
本文回顾了Java语言的发展历史、主要特点以及代码从源文件到解释执行的过程，同时介绍了Java实现可移植性的原理。可以知道Java语言经历了多个阶段的发展，不断引入新技术和特性。从JDK1.0到现在的最新版本，Java变得更加强大、成熟和全面。它具有简洁有效、可移植性、面向对象、健壮性、高安全性以及动态语言等重要特点。而代码从源文件到解释执行，首先会通过编译器将源文件转换为字节码文件。然后，Java虚拟机（JVM）将字节码加载到内存中，并通过解释器逐行执行字节码...
Java8新特性Stream流详解
陈老老老板的博客
10-25 2万+
既然我们已经知道了这些强大的内置收集器，接下来就让我们尝试构建自定义收集器吧。比如说，我们希望将流中的所有人转换成一个字符串，包含所有大写的名称，并以|分割。为了达到这种效果，我们需要通过Collector.of()创建一个新的收集器。同时，我们还需要传入收集器的四个组成部分：供应器、累加器、组合器和终止器。
Java高频面试题 - Java、SpringCould、中间件
a111042555的博客
04-19 6296
面试题
JAVA学习路书-2024年最新版
qq_43896330的博客
05-29 931
首先，我们要认识到，这几年就业形式确实是不太好，到处都是“Java卷爆了”的言论。对于这些言论，要分为两个部分一方面，确实现在的就业形式比较严峻，因此对于我们的要求已经大大提高。作为一名Java开发者，不仅需要掌握扎实的基础知识，还需要熟悉各种框架和工具，并具备解决复杂问题的能力，所以我们要做好长时间学习的准备。另一方面，现在Java仍然是需求量最大的编程语言。根据各种招聘网站的数据统计，Java相关的职位需求量始终位居前列。
Java NIO(一)-----Channel
niulinbiao的博客
09-20 162
文章预览前言1、Java NIO简介2、Channel简介一、Channel的使用方法1.1、FileChannel1.1.1、FileChannel读取操作1.1.2、FileChanne写操作1.1.3、通道之间数据传输1.2、SocketChannel1.2.1、Demo1.3、ServerSocketChannel1.3.1、一个非阻塞的 accept( )方法：1.4、DatagramChannel1.4.1、demo 前言 1、Java NIO简介 Java NIO（New IO 或 Non B
运维人常用linux命令--吐血整理（持续更新）
qq_43723172的博客
12-11 931
常用linux命令
Java8新特性-掉头发整理跑路必备 罒ω罒
程序员的日常学习
11-05 782
Java8新特性-掉头发整理跑路必备 罒ω罒 说明 本片文章，建议先查看目录。可直接当做API来查询。 虽然工作上已经升级到Java8挺久的了，但是还没有，完整使用上它的一些特性。 尤其是Lambda 表达式，一些的写法灰常的简洁，虽然效率上并不一定很高。╮(╯_╰)╭ (毕竟源码上还是常规操作的封装语法糖，但它优雅啊 罒ω罒) 参考 先把参考文章贴出来，这些文章都很好的。各种具体的详情，请查看参考原文会更具体。 如果只是当做工具API查阅的话，可以直接按目录查找。 博客园-JAVA8新特性
超级详细！！！SpringCloud完整知识点整理上篇 （涵盖知识点：Eureka、Zookeeper、Consul、Ribbon、Openfeign、Hystrix）
weixin_45203539的博客
08-07 231
所有配套资料已上传到QQ群：167356412 需要的话群文件自取 Spring Cloud中国社区官网:http://springcloud.cn Spring Cloud中国社区论坛:http://bbs.springcloud.cn Spring Cloud中国社区文档:http://docs.springcloud.cn 一、理论入门 1、2020年2月以前流行的微服务技术方案 2、教程视频版本号 3、SpringBoot与SpringCloud对应版本 二、回...
Stream-Video-Downloader-10.0.2.crx 下载
09-01
Stream-Video-Downloader-10.0.2.crx
redis-stream-vscode:欢迎使用 vscode 的 redis 流扩展！
05-30
用于 vscode 的 redis-stream ！ 欢迎使用 vscode 的 redis-stream 扩展！ 特征 MQ通过redis流，可以delayQueue： 。 使用： npm i redis-stream-queue __keyevent@5__:expired消息( __keyevent@5__:expired )不...
stream-chat-python：流聊天官方Python API客户端
02-09
流聊天python 的官方Python API客户端，用于构建聊天应用程序的服务。 您可以在注册Stream帐户。 您可以使用此库在服务器端访问chat API端点，有关客户端集成（Web和移动），请查看Javascript，iOS和Android SDK库...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 625
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 706
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 953
GeoServerBasePage 登录
Javase.认识异常
最新发布
Joseit的博客
06-21 1136
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
java 解析application/octet-stream
05-16
对于Java解析application/octet-stream类型的数据，可以使用Java IO或NIO API来读取和处理二进制数据流。具体方法可以参考以下代码： ```java try (FileInputStream inputStream = new FileInputStream("your_file_path"); ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) { byte[] buffer = new byte[1024]; int length; while ((length = inputStream.read(buffer)) != -1) { outputStream.write(buffer, 0, length); } byte[] bytes = outputStream.toByteArray(); // 处理二进制数据流 } catch (IOException e) { e.printStackTrace(); } ``` 注意，在处理二进制数据流时要注意数据的编码方式、格式以及具体的业务需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值