Java之jdk8新特性

最新推荐文章于 2023-04-17 17:05:10 发布
最新推荐文章于 2023-04-17 17:05:10 发布
阅读量204 收藏 1
点赞数 2
分类专栏： Java核心基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L__HH/article/details/125099362
版权

😀😀😀创作不易，各位看官点赞收藏.

Java之jdk8新特性

文章目录


Java8为Java语言、编译器、类库、开发工具与JVM带来了大量的新特性。例如函数式接口、Lambda表达式、Stream、接口的静态方法和默认方法、集合中的新特性、Optional类、新日期类等。

1、Lambda 表达式

1.1、函数式接口

函数式接口：只包含一个抽象方法的接口，但是可以拥有静态方法和默认方法，称为函数式接口。在java.util.function包下定义了Java 8丰富的函数式接口。

// 这个注解是用来检查这个接口是否为函数式接口，可以不使用这个注解
@FunctionalInterface
public interface MyInterface {

    // 只有一个抽象方法
    void method1();
    
    // 静态方法
    static void method2(){
        System.out.println("我是函数式接口中的静态方法");
    }
    
    // 默认方法
    default void method3(){
        System.out.println("我是函数式接口中的默认方法");
    }
}

@FunctionalInterface注解：使用在接口上，检查该接口是否为函数式接口，同时在Javadoc中也会包含函数接口这条声明。

在Java中内置了很多的函数式接口，核心的4大函数式接口：

image-20220531161148781

public static void main(String[] args) {
    // 消费性接口：需要一个参数，没有返回值
    Consumer<String> consumer = s -> {
        System.out.println("我是消费型接口==>"+s);
    };
    consumer.accept("Hello,World");

    // 供给型接口：不需要参数，有返回值
    Supplier<String> supplier = () -> {
        int a = 100;
        return a+"分";
    };
    System.out.println(supplier.get());

    // 函数式接口：有一个参数，返回值是另一个类型的参数
    Function<String,Integer> function = s ->{ // <>泛型第一个是参数类型，第二个是返回值类型
        System.out.println("我是参数式接口===>"+s);
        return 100;
    };
    System.out.println(function.apply("Hello,World"));

    // 判定型接口，有一个参数，返回值是boolean
    Predicate<Integer> predicate = num ->{
        return num>0;
    };
    System.out.println(predicate.test(-10)); // false
}

1.2、使用Lambda

Lambda表达式：是一个匿名函数，一段可以传递的代码。使用它可以写出简洁、灵活的代码，一种新的语法格式。它可以创建一个函数式接口的实现类，针对函数式接口使用Lambda表达式创建一个实现类。

public static void main(String[] args) {
    // Comparator接口是一个函数式接口

    // 不使用Lambda表达式，创建一个接口匿名子类对象
    Comparator<Integer> comparator1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1,o2);
        }
    };
    System.out.println(comparator1.compare(29, 30));

    // 使用Lambda表达式来创建一个接口匿名子类，因为接口中只有一个方法，直接可以省略方法名，只写方法体就可以
    Comparator<Integer> comparator2 = (o1,o2) -> {
        return Integer.compare(o1,o2);
    };
    System.out.println(comparator2.compare(32, 12));
}

Lambda形式：

  • -> ：lambda操作符或者叫箭头操作符。
  • 箭头左边(o1,o2)：lambda的形参列表(本质是接口抽象方法的形参列表)。
  • 箭头右边：lambda体(重写接口抽象方法的方法体)。
// (o1,o2) 是形参列表，如果没有参数直接是一个括号，可以表明参数的类型(Integer o1,Integer o2)，也可以不用标明的直接通过类型推断就可以知道
// {方法体} 重写接口方法的方法体
Comparator<Integer> comparable = (o1, o2) -> {
    return Integer.compare(o1,o2);
};

// 如果参数列表只有一个参数，可以省略小括号，但是没有参数时必须加上小括号
Consumer<String> consumer = s -> {
    System.out.println(s);
};

// 当lambda体只有一条语句时，可以把大括号省略，如果有返回值，也可以将return省略
Comparator<Integer> comparable1 = (o1, o2) -> Integer.compare(o1,o2);

Lambda表达式必须依赖于函数式接口，只能创建函数式接口的实现类。

1.3、方法引用

方法引用：当传递给Lambda方法体中，已经有实现方法了，就可以使用方法引用了。要求：实现接口的抽象方法的参数列表和返回值类型必须和方法引用的参数列表和返回值类型一样。方法引用的操作符是 ::，方法引用本质上是一个Lambda，Lambda是一个函数式接口的实例，那么方法引用也是一个函数式接口的实例对象。

方法引用的三种情况：

  • 对象 :: 非静态方法名
  • 类 :: 静态方法名
  • 类 :: 非静态方法名
// 对象 :: 非静态方法
public static void main(String[] args) {
    // 不使用引用方法
    Consumer<String> consumer1 = s -> {
        System.out.println(s);
    };
    consumer1.accept("Hello,World");

    // 因为Consumer接口的accept方法与System.out对象的println()都是一个String参数没有返回值
    // 这样就可以使用方法引用，使用方法引用来替换Lambda表达式
    Consumer<String> consumer2 = System.out::println;
    consumer2.accept("Hello,World");
}

// 类::静态方法
public static void main(String[] args) {
    // 不使用方法引用
    Comparator<Integer> comparator1 = (o1,o2) -> {
        return Integer.compare(o1,o2);  
    };
    System.out.println(comparator1.compare(10, 2));

    // Comparator的compare方法和Integer.compare静态方法的参数列表和返回值相同，可以使用方法引用
    Comparator<Integer> comparator2 = Integer::compare;
    System.out.println(comparator2.compare(3, 10));
}

// 类::非静态方法
public static void main(String[] args) {
    // 不使用方法引用
    Comparator<String> comparator1 = (s1,s2) -> {
        return s1.compareTo(s2);
    };
    System.out.println(comparator1.compare("adb", "adt"));

    // 使用方法引用，类::非静态方法
    /* 要求：
         如果接口有两个参数，第一个参数需要作为方法的调用者；
         如果接口有一个参数，参数需要作为方法的调用者
    */
    Comparator<String> comparator2 = String::compareTo; // s1.compareTo(s2)，第一个参数作为了方法的调用者
    System.out.println(comparator2.compare("abc", "abcd"));
}

构造器引用：

// 构造器引用
public static void main(String[] args) {
    // 不使用构造器引用
    Function<Integer,User> function1 = (id) -> {
        return new User(id);
    };
    System.out.println(function1.apply(1001));

    // 使用构造器引用，构造器的参数列表和函数式抽象方法得参数列表要相同
    // 这个相当于是调用了某个类的构造器，创建了一个对象
    Function<Integer,User> function2 = User::new;
    System.out.println(function2.apply(1002));
}

数组引用：

// 数组引用：可以看成一个构造器引用
public static void main(String[] args) {

    // 不使用数组引用
    Function<Integer,String[]> function1 = integer -> {
        return new String[integer];
    };
    System.out.println(Arrays.toString(function1.apply(10)));

    // 使用数组引用
    Function<Integer,String[]> function2 = String[]::new;
    System.out.println(Arrays.toString(function2.apply(5)));
}

2、Stream API

Stream：把真正的函数式编程风格引入Java中，是目前Java类库最好的补充，它可以让程序更加简洁、高效。使用Stream对集合中数据进行计算操作，类似于SQL执行的数据查询，是一种高效且容易的一种数据处理方式。

Stream特点：

  • 数一种数据渠道，操作数据源(集合、数组)所在的元素序列。
  • 它不会自己存放数据。
  • 它不会改变数据源，会返回一个新持有结构的Stream。
  • 它是延迟操作的，只有它需要结果的时候才会进行计算数据。

Stream的三个步骤：

  • 创建Stream：通过一个数据源获取一个Stream流。
  • 中间操作：对数据源的处理。
  • 终止操作：一旦执行终止操作，就会执行中间操作，并产生对应的结果。

image-20220531200544342

2.1、Stream实例化

集合方式实例化Stream流：

// 集合实例化Stream流
public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("hello");
    list.add("world");
    list.add("你好");
    // 实例化一个Stream流
    Stream<String> stream1 = list.stream(); // 实例化集合的一个顺序流
    Stream<String> stream2 = list.parallelStream(); // 实例化集合的一个并行流
}
  • 顺序流：在操作集合数据时，选择数据是按照集合中的顺序一个一个操作。
  • 并行流：同时会有对个线程对多个数据并行进行操作。

数组方式实例化Stream流：

// 数组方式实例化Stream流
public static void main(String[] args) {
    String[] array = new String[]{"张三","李四","王五"};

    // 通过Arrays的stream()方法，参数是一个数组
    Stream<String> stream = Arrays.stream(array);
}

Stream类实例化：

public static void main(String[] args) {
    // 参数是一个可变参数，这些元素作为数据源
    Stream<String> stream = Stream.of("张三", "李四", "王五");
}

2.2、中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行。而且在触发终止操作时，会一次性将中间操作全部执行完成，称为惰性求值。

2.2.1、筛选和切片

image-20220531204259703

// Stream流中的筛选和切片
public static void main(String[] args) {
    List<Integer> array = Arrays.asList(29, 34, 34, 35, 12, 23, 67, 12, 1, 2, 3);

    Stream<Integer> stream = array.stream();
    // 筛选
    // filter()参数是一个Predicate的判定型接口，forEach()是一个遍历的终止操作参数是一个消费函数式接口
    // 这样才会执行中间操作才会有结果
    stream.filter(num -> num>20).forEach(System.out::println);
    System.out.println();

    stream = array.stream();
    // limit()只会选择前n个元素，n作为参数
    stream.limit(10).forEach(System.out::println);
    System.out.println();

    stream = array.stream();
    // 这会根据元素的重写的hashcode()和equals()方法去掉重复数据
    stream.distinct().forEach(System.out::println);
    System.out.println();

    stream = array.stream();
    // 这会跳过前n个元素，n是参数，如果元素个数小于n就会返回一个空的stream流
    stream.skip(3).forEach(System.out::println);
}
2.2.2、映射

映射：将每一个元素通过一系列操作，返回一个新的数据。类似函数中自变量每一个x会对应一个y值。

// 映射
public static void main(String[] args) {
    List<User> list = new ArrayList<>();
    list.add(new User(1001,"张三1"));
    list.add(new User(1002,"张三2"));
    list.add(new User(1003,"张三3"));
    list.add(new User(1004,"张三4"));
    list.add(new User(1005,"张三5"));

    // 将集合中user的名称提取出来
    Stream<User> stream = list.stream();
    // map()参数是一个函数式接口，存在一个参数返回一个新的数据
    // 参数是一个user对象，返回值是一个user名称字符串
    stream.map(User::getName).forEach(System.out::println);

    stream = list.stream();
    // flatMap()：每一个元素将返回的数值当成一个新的stream，然后将每一个stream流拼接起来
    stream.flatMap(user->{
        String[] array = new String[]{user.getName()}; // 将name加入到一个String数组
        return Arrays.stream(array); // 返回一个stream流
    }).forEach(System.out::println);
}
2.2.3、排序

image-20220601195230750

// 排序
public static void main(String[] args) {
    List<Integer> list = Arrays.asList(14, 34, 2, -90, 23, 43, -3);
    Stream<Integer> stream = list.stream();

    // sorted()：会根据元素中的实现的comparable进行排序，如果没有实现接口就会报错
    stream.sorted().forEach(System.out::println); // 从小到大
    System.out.println();

    stream = list.stream();
    // sorted(CompareTo c)：会根据自定的CompareTo接口进行排序
    stream.sorted((e1,e2)->-(e1-e2)).forEach(System.out::println); // 从大到小
}

2.3、终止操作

终止操作：终止操作会执行对应的中间操作，其结果可以是任何不是流的值，例如List、Integer、void等。流进行了终止操作后，就不能在继续操作流了不然会报错。

2.3.1、匹配和查询

image-20220601202617073

// 匹配
public static void main(String[] args) {
    List<Integer> list = Arrays.asList(23, 4, 1, -25, 0, 19, 65);
    Stream<Integer> stream = list.stream();

    // allMatch() 参数是一个判断性函数式接口，如果所有元素都满足条件就返回true
    boolean match1 = stream.allMatch(e -> e >= 0);
    System.out.println(match1); // false

    stream = list.stream();
    // anyMatch() 参数是判断型函数接口，如果有一个元素满足条件就返回true
    boolean match2 = stream.anyMatch(e -> e >= 100);
    System.out.println(match2); // false

    stream = list.stream();
    // noneMatch() 参数是判断型接口，没有任何元素匹配就返回true
    boolean match3 = stream.noneMatch(e -> e >= 100);
    System.out.println(match3); // true

    stream = list.stream();
    // 返回流中的第一个元素
    Optional<Integer> first = stream.findFirst();
    System.out.println(first);

    stream = list.parallelStream();
    // 返回流中任意一个元素，对于顺序流一般是第一个元素，如果是并行流是随机一个元素
    Optional<Integer> any = stream.findAny();
    System.out.println(any);
}

// 查找
public static void main(String[] args) {
    List<Integer> list = Arrays.asList(23, 4, 1, -25, 0, 19, 65);
    Stream<Integer> stream = list.stream();

    // 查询流中大于10元素的个数
    long count = stream.filter(e -> e>10).count();
    System.out.println(count);

    stream = list.stream();
    // 查询流最大元素，参数是一个Comparator函数式接口
    Optional<Integer> max = stream.max(Integer::compare);
    System.out.println(max);

    stream = list.stream();
    // 查询流中最小元素，参数是Comparator函数式接口
    Optional<Integer> min = stream.min(Integer::compare);
    System.out.println(min);

    stream = list.stream();
    // 内部迭代，参数是一个消费型函数接口
    stream.forEach(System.out::println);

    // 集合中的forEach()方法，参数也是一个消费型接口
    list.forEach(System.out::println);
}
2.3.2、归约

image-20220602121608920

// 归约：将流中的数据结合起来得到一个值
public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    Stream<Integer> stream = list.stream();

    // 求集合中元素的总和，初始值是0
    // reduce() 参数一：初始值；参数二：一个BinaryOperator函数式接口，两个参数一个返回值
    Integer sum1 = stream.reduce(0, (e1,e2) -> e1+e2);
    System.out.println(sum1);

    stream = list.stream();
    // reduce() 只有一个参数BinaryOperator函数式接口时，它只返回一个Option<T>值，将流中的数据反复结合起来
    // 他没有初始值，只会根据元素类型进行结合
    Optional<Integer> sum2 = stream.reduce(Integer::sum);
    System.out.println(sum2);
}
2.3.3、收集

image-20220602123048649

​ Collector这个接口的实现决定了对流执行收集的操作(收集到List、Set、Map)。Collectors类是一个工具类提供了很多静态方法，可以创建常见的收集器实例。下图是Collectors的一些静态方法：

image-20220602124409542

// 收集：将stream流中的数据收集到一个集合中
public static void main(String[] args) {
    List<Integer> list = Arrays.asList(45, 2, -10, 32, -9, 2, -78,90,23);
    Stream<Integer> stream = list.stream();

    // collect()参数是一个Collector接口实例，通过Collectors来创建对应实例
    List<Integer> result = stream.filter(e -> e > 10).collect(Collectors.toList());
    result.forEach(System.out::println);
}

3、Optional 类

Optional：一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null值表示这个值不存在。原来使用null来表示一个值不存在，现在可以使用Optional类来表示可以避免空指针异常问题。

3.1、实例化Optional类
// 实例化Optional类
public static void main(String[] args) {
    User user = new User();

    // of()参数是一个存放的数据，不要保证数据不为null，如果为null会报错
    Optional<User> optional1 = Optional.of(user);

    // 创建一个数据为null的Optional类
    Optional<Object> optional2 = Optional.empty();

    user = null;
    // ofNullable()参数是存放的数据，存放的数据可以为空
    Optional<User> optional3 = Optional.ofNullable(user);
}
3.2、常用方法

判断型方法：

// 判断型方法
public static void main(String[] args) {
    User user = new User();

    user = null;
    Optional<User> optional = Optional.ofNullable(user);
    // 判断容器中是否存在数据，数据为null返false
    boolean b1 = optional.isPresent();
    System.out.println(b1); // false

    optional = Optional.ofNullable(new User("张三"));
    // 参数是一个消费型接口，如果存放数据不为null就将数据作为消费型接口的参数
    // 如果数据为空就不会执行消费型接口实现类中的方法
    optional.ifPresent(System.out::println);
}

获取数据方法：

// 获取数据方法
public static void main(String[] args) {
    User user = new User("张三");
    Optional<User> optional = Optional.ofNullable(user);

    // 返回容器中存放的数据，如果数据为null会报错
    User user1 = optional.get();
    System.out.println(user1); // 张三

    optional = Optional.ofNullable(null);
    // orElse() 参数是一个备胎参数，如果容器中的数据为null，它会返回参数这个对象
    User user2 = optional.orElse(new User("李四"));
    System.out.println(user2); // 李四

    // 参数是一个供给型函数接口，如果容器数据为null，它会返回供给型接口的返回值
    User user3 = optional.orElseGet(()->new User("王五"));
    System.out.println(user3); // 王五

    // 参数是一个供给型函数式接口，如果数据为null，它会抛出一个供给型函数接口抛出的异常
    User user4 = optional.orElseThrow(() -> new RuntimeException("数据为空")); // 这里会抛出异常
    System.out.println(user4);
}
sun-flower__
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
compare()Java_Java Integer compare()用法及代码示例
weixin_39926014的博客
02-12 2077
java.lang包的Integer类的compare()方法比较作为参数给出的两个整数值(x，y)，如果(x == y)则返回零，如果(x y)，则返回大于零的值。用法:public static int compare(int x, int y)参数：x: the first int to comparey: the second int to compare返回：This method r...
Integer中方法compare和compareTo的区别
热门推荐
fly_fly_fly_pig的博客
09-17 2万+
从名字上我们就可以大概才出来他们的区别,compareTo的参数是一个整数,是对象的方法.相对之下compare的参数应该就是两个,是类的方法. 再来看看源码 //compareTo public int compareTo(Integer anotherInteger) { return compare(this.value, anotherInteger...
Java：Integer中的compare与compareTo
超级马里奥 的博客
11-09 2527
Java：Integer中的compare与compareTo 首先我们先来查看一波jgk1.8： 1.compareTo compareTo(Object o)方法是java.lang.Comparable<T>接口的方法； 重写compareTo方法，进行自然排序（aka整体排序、内部排序）：Collections.sort(), Array.sort()；这些排序方法默认的是升序的 实现了这个接口的的对象，就有了排序的功能，所以叫comparable--可排序的； co..
Java Integer.compareTo()具有什么功能呢？
qq_25073223的博客
08-26 1018
Java Integer.compareTo()方法的功能简介说明
javaSE基础全覆盖
小白的进化路
07-26 268
面向对象 概念： 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。 类：对一类事物的描述，是抽象的、概念上的定义 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance) 对象是由类new出来的，派生出来的。 属性 = 成员变量 = field = 域、字段 方法 = 成员方法 = 函数 = method 创建类的对象 = 类的实例化 = 实例化类 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属
JDK8新特性（pdf版）
06-26
JDK8新特性课程内容包括了解Java发展史、Lambda表达式、接口的增强、函数式接口、方法引用、Stream API、Optional、新时间日期API等。 一、Java发展历史 Java的发展历史可以追溯到1991年，Sun公司成立了一个称为...
JavaJDK新特性8-15详细视频讲解合集
04-27
本课程专门针对JDK8-15新特性进行一一讲解，每个新特性都进行案例演示，通俗易懂易学习。 讲解方式： 课程讲解通俗易懂，课程重点剖析模块化系统、交互式编程。 课程内容： 课程讲解通俗易懂，课程重点剖析模块化...
jdk8新特性.zip
09-29
JDK1.8已经发布很久了，在很多企业中都已经在使用。并且Spring5、SpringBoot2.0都推荐使用JDK1.8以上版本...Java8新特性如下： Lambda表达式 函数式接口 方法引用 接口的默认方法和静态方法 Optional Streams 并行数组
JDK8核心新特性
06-20
JDK8已经发行有几年了，在该版本中推出了不少新特性，其中比较有代表的新特性有：Lambda表达式，Stream流，方法引用。在网上也有很多关于这些新特性的介绍，但个人觉得网上的很多文字对新特性的介绍是不够全面的，...
Java 基础：Integer 源码分析
Herishwater的博客
09-28 277
基本数据类型 int 的包装类即为 Integer，纵观 Integer、Long、Float、Double 数值类的源码，觉得 Integer 类的内容更加丰富，包含的小知识点更多，因此决定研究一下该类的源码，顺便做一下知识总结。该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。 类定义 public final ...
Java排序专题
littleNerd的博客
01-03 288
Java排序专题
Integer的相关函数
weixin_47655735的博客
11-11 2118
一，int和integer的区别 int是Java的基本类而Integer是Java的包装类； int的声明不需要实例化而Integer的声明需要； int默认值为0，Integer的默认值为null； 二，Integer.valueOf(String s) 返回Integer 将字符串转化为Integer||int； 三，Integer.valueOf（int x）返回Integer public static Integer valueOf(int i) { a.
Java比较总结（compare、Comparable、compareTo、Comparator、sort+Comparator)
Tonq_csdn
12-03 6603
compare and sort
Integer类常见方法
yl23921的博客
09-26 3841
Integer类常见方法及简单使用
Java中Integer类型的整数值的大小比较
MissOfSpring的博客
04-29 1万+
1.规则 如果Integer类型的两个数相等，如果范围在-128~127（默认），那么用“==”返回true，其余的范会false。 两个基本类型int进行相等比较，直接用==即可。 一个基本类型int和一个包装类型Integer比较，用==也可，比较时候，Integer类型做了拆箱操作。 Integer类型比较大小，要么调用Integer.intValue()转为基本类型用“==”比较，要么直接用equals比较。 Java Integer.compareTo()比较大小 2.定义
【Java8新特性 Lambda表达式-Stream API详解】
qq_44682003的博客
11-07 345
Java8 新特性一、为什么使用Lambda表达式二、Lambda表达式基础语法 一、为什么使用Lambda表达式 Lambda是一个匿名函数，我么可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样传递）。可以写出更加简洁的、灵活的代码。作为一种更紧凑的代码风格，使java语言能力得到了提升 看不懂没关系，上代码我们先体会体会： （补充：匿名内部类） 匿名内部类去实现 Comparator接口： public class TestLambda1{ //匿名内部类 pub
Java_第18章_JDK8-17新特性（上）
最新发布
qq_52922453的博客
04-17 794
发行版本发行时间备注Java 1.01996.01.23Sun公司发布了Java的第一个开发工具包Java 5.02004.09.30①版本号从1.4直接更新至5.0；②平台更名为JavaSE、JavaEE、JavaMEJava 8.02014.03.18此版本是继Java 5.0以来变化最大的版本。是长期支持版本（LTSJava 9.02017.09.22此版本开始，每半年更新一次Java 10.02018.03.21Java 11.02018.09.25。
Java常用类库学习总结
qq_51553982的博客
08-02 847
常用类库 包装类 Java中不能定义基本数据类型的对象，为了能将基本数据类型当作对象处理，包装类由此诞生！ 概念： 将基本数据类型封装在包装类中,以便把这些基本数据类型转换为对象进行处理 包装类以及所对应的基本数据类型： 包装类 对应基本数据类型 Byte byte Integer int Float float Character char Short short Long long Double double Boolean boolean 1.Inte
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值