jdk1.8特性

最新推荐文章于 2024-06-12 23:40:32 发布
最新推荐文章于 2024-06-12 23:40:32 发布
阅读量98 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52489741/article/details/130132871
版权

# Lambda表达式

### 例子

- 例子1

```java

  //匿名内部类

  Comparator<Integer> cpt = new Comparator<Integer>() {

      @Override

      public int compare(Integer o1, Integer o2) {

          return Integer.compare(o1,o2);

      }

  };

  TreeSet<Integer> set = new TreeSet<>(cpt);

  System.out.println("=========================");

  //使用lambda表达式

  Comparator<Integer> cpt2 = (x,y) -> Integer.compare(x,y);

  TreeSet<Integer> set2 = new TreeSet<>(cpt2);

```

- 例子2   System.out::println

```java

// 创建出一个数组

        List<String> strList = Arrays.asList("YangHang", "AnXiaoHei", "LiuPengFei");

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

```


 

### 分别使用成员内部类、局部内部类、静态内部类、匿名内部类方式实现Runnable的run()方法并创建和启动线程,如下所示:

```java

public class LambdaDemo {

    /**

     * 成员内部类

     */

    class MyThread01 implements Runnable{

        @Override

        public void run() {

            System.out.println("成员内部类：用Lambda语法创建线程吧!");

        }

    }

    /**

     * 静态内部类

     */

    static class MyThread02 implements Runnable{

        @Override

        public void run() {

            System.out.println("静态内部类：对啊，用Lambda语法创建线程吧!");

        }

    }

    public static void main(String[] args) {

        /**

         * 局部内部类

         */

        class MyThread03 implements Runnable{

            @Override

            public void run() {

                System.out.println("局部内部类：用Lambda语法创建线程吧!");

            }

        }

        /**

         * 匿名内部类

         */

        Runnable runnable = new Runnable(){

            @Override

            public void run() {

                System.out.println("匿名内部类：求求你，用Lambda语法创建线程吧!");

            }

        };

        //成员内部类方式

        LambdaDemo lambdaDemo = new LambdaDemo();

        MyThread01 myThread01 =lambdaDemo.new MyThread01();

        new Thread(myThread01).start();

        //静态内部类方式

        MyThread02 myThread02 = new MyThread02();

        new Thread(myThread02).start();

        //局部内部类

        MyThread03 myThread03 = new MyThread03();

        new Thread(myThread03).start();

        //匿名内部类的方式

        new Thread(runnable).start();

    }

}

```

- 使用lambda表达式启动线程

```java

 //Lambda方式

new Thread(() -> System.out.println("使用Lambda就对了")).start();

```

## lambda语法

- Lambda表达式在Java语言中引入了一个操作符**“——>”**，该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分：

    左侧：指定了Lambda表达式需要的所有参数

    右侧：制定了Lambda体，即Lambda表达式要执行的功能。

eg：(parameters) -> expression

或  (parameters) ->{ statements; }

### lambda表达式特征（语法格式）

```java

@Data

public class LambdaExpression {

    interface LambdaInterface01 {

        public void fun(String str);

    }

    interface LambdaInterface02 {

        public void fun(String str, int i);

    }

    interface LambdaInterface33 {

        public int sum(int x, int y);

    }

    interface LambdaInterface34 {

        public String fun();

    }

    interface LambdaInterface666{

        public void fun();

    }

    //    基于lambda表达式实现

    public static void main(String[] args) {

        //一个string 入参；无返回值

        LambdaInterface01 lambdaInterface01 = (String str) -> System.out.println("我是第" + str + "个Lambda表达式");

        lambdaInterface01.fun("1");

        // 两个参数，无返回值

        LambdaInterface02 lambdaInterface02 = (x, y) -> System.out.println(x + "666" + y);

        lambdaInterface02.fun("华夏", 666);

        //两参数，有返回值

        LambdaInterface33 lambdaInterface33 = (x, y) -> {

            int sum = x + y;

            return sum;

        };

        int sum = lambdaInterface33.sum(100, 200);

        System.err.println("100+200=" + sum);

        //无参，有返回

      LambdaInterface34 lambdaInterface34=  ()->{

            System.out.println("这是无参有返回");

            return "无参有返回";

        };

        String result = lambdaInterface34.fun();

        System.err.println(result);

        //无参，无返回

       LambdaInterface666 lambdaInterface666= ()-> System.out.println("无参无返回的表达");

       lambdaInterface666.fun();

    }

}

```

# 函数式接口

# 方法引用和构造器调用

### 方法引用

- 三种表现形式

1. 对象：：实例方法名

2. 类：：静态方法名

3. 类：：实例方法名 （lambda参数列表中第一个参数是实例方法的调用 者，第二个参数是实例方法的参数时可用）

```java

 public void test() {

        /**

        *注意：

        *   1.lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！

        *   2.若lambda参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用ClassName::method

        *

        */

        Consumer<Integer> con = (x) -> System.out.println(x);

        con.accept(100);

        // 方法引用-对象::实例方法

        Consumer<Integer> con2 = System.out::println;

        con2.accept(200);

        // 方法引用-类名::静态方法名

        BiFunction<Integer, Integer, Integer> biFun = (x, y) -> Integer.compare(x, y);

        BiFunction<Integer, Integer, Integer> biFun2 = Integer::compare;

        Integer result = biFun2.apply(100, 200);

        // 方法引用-类名::实例方法名

        BiFunction<String, String, Boolean> fun1 = (str1, str2) -> str1.equals(str2);

        BiFunction<String, String, Boolean> fun2 = String::equals;

        Boolean result2 = fun2.apply("hello", "world");

        System.out.println(result2);

    }

```

### 构造器引用

- 格式：ClassName::new

```java

public void test2() {

        // 构造方法引用  类名::new

        Supplier<Employee> sup = () -> new Employee();

        System.out.println(sup.get());

        Supplier<Employee> sup2 = Employee::new;

        System.out.println(sup2.get());

        // 构造方法引用 类名::new （带一个参数）

        Function<Integer, Employee> fun = (x) -> new Employee(x);

        Function<Integer, Employee> fun2 = Employee::new;

        System.out.println(fun2.apply(100));

 }

```

### 数组引用

- 格式：Type[]::new

```java

public void test(){

        // 数组引用

        Function<Integer, String[]> fun = (x) -> new String[x];

        Function<Integer, String[]> fun2 = String[]::new;

        String[] strArray = fun2.apply(10);

        Arrays.stream(strArray).forEach(System.out::println);

}

```


 

# Stream API

# Stream 流的使用

## 基本用法

- map  取对象的某一列

```java

// Stream流

List<String> userNameList = userList.stream().map(User::getName).collect(Collectors.toList());

```

- filter 过滤

```java

// 获取userName不为空的user的List

List<User> userList = userList.stream().filter(user-> user.getName() != null).collect(Collectors.toList());

```

- groupingBy 分组

```java

Map<String, List<User>> map =userList.stream().collect( Collectors.groupingBy(User::getAge, Collectors.toList()));

```

- sum 求和

```java

// int、double、long:

double max = userList.stream().mapToDouble(User::getHeight).sum();

```

- Map和List互转

//list转map

```java

//list转map

Map<String, User> userMap= userList.stream().collect(Collectors.toMap(User::getName, Function.identity(),(key1, key2)->key2));

```

//map转list

```java

//map转list

   List<User> userList = userMap.entrySet().stream().map(e ->e.getValue()).collect(Collectors.toList());

```

## 做判断

- anyMatch()  判断的条件里，任意一个元素成功，返回true;

```java

    userList.stream().anyMatch(user -> user.getHeight() > 175);

```

- allMatch()  判断条件里的元素，所有的都是，返回true；

```java

    userList.stream().allMatch(user -> user.getHeight() > 175);

```

- noneMatch()  判断条件里的元素，所有的都不是，返回true

```java

    userList.stream().noneMatch(user -> user.getHeight() > 175);

```

- 求取目标和

```java

    userList.stream().filter(user -> user.getHeight() > 175).count();

```

## 合并list

- 合并多个一维list

```java

   List<Integer> list1 = Arrays.asList(1, 2, 3);

   List<Integer> list2 = Arrays.asList(4, 5, 6);

   List<Integer> list3 = Arrays.asList(7, 8, 9);

   List<Integer> mergedList = Stream.of(list1, list2, list3).flatMap(Collection::stream).collect(Collectors.toList());

   System.out.println(mergedList);// [1, 2, 3, 4, 5, 6, 7, 8, 9]

```

- 合并嵌套list

```java

   List<String> list1 = Arrays.asList("张三", "李四", "王二麻子");

   List<String> list2 = Arrays.asList("111", "222", "333");

   // 合并前

   List<List<String>> lists = Arrays.asList(list1, list2);

   System.out.println(lists);

   

   // 合并后

   List<String> mergedList = lists.stream().flatMap(Collection::stream).collect(Collectors.toList());

   System.out.println(mergedList);

```

## 分页

```java

        Map<String,Object> map = Maps.newHashMap();

        List list = new ArrayList();

        //list -> 当前页所有数据

        map.put("list",list.stream().skip((long) (pageNo - 1) * pageSize).limit(pageSize).collect(Collectors.toList()));

        //count -> 记录总条数

        map.put("count",list.size());

```

# 接口中的默认方法和静态方法


 

# 新时间日期API

LocalDate | LocalTime | LocalDateTime

表示日期的LocalDate

表示时间的LocalTime

表示日期时间的LocalDateTime




 

# 补充知识---Java内部类

### 普通内部类(成员内部类)

```java

/**

 * 普通内部类

 * 创建内部类的对象，首先需要创建外部类对象

 * 外部类对象去调普通内部类的构造器

 * 外部对象.new 内部类构造器

 */

@Data

public class InnerClassTest {

    //  外部类的属性

    public int outFiled1 = 1;

    protected int outFiled2 = 2;

    int outFiled3 = 3;

    private int outFiled4 = 4;

    // 无参构造

    public InnerClassTest() {

//        System.out.println("创建"+this.getClass().getSimpleName()+"对象");

//        创建普通内部类对象

        InnerClassA innerobj = new InnerClassA();

        System.err.println("创建" + this.getClass().getSimpleName() + "对象");

        System.out.println("其内部类的 field1 字段的值为: " + innerobj.innerFiled1);

        System.out.println("其内部类的 field2 字段的值为: " + innerobj.innerFiled2);

        System.out.println("其内部类的 field3 字段的值为: " + innerobj.innerFiled3);

        System.out.println("其内部类的 field4 字段的值为: " + innerobj.innerFiled4);

    }

    //    普通内部类

    @Data

    public class InnerClassA {

        public int innerFiled1 = 5;

        protected int innerFiled2 = 6;

        int innerFiled3 = 7;

        private int innerFiled4 = 8;

        // 内部无参构造

        public InnerClassA() {

            System.err.println("创建" + this.getClass().getSimpleName() + "对象");

            System.out.println("其内部类的 field1 字段的值为: " + outFiled1);

            System.out.println("其内部类的 field2 字段的值为: " + outFiled2);

            System.out.println("其内部类的 field3 字段的值为: " + outFiled3);

            System.out.println("其内部类的 field4 字段的值为: " + outFiled4);

        }

    }

    public static void main(String[] args) {

//        创建外部类对象

        InnerClassTest outerObj = new InnerClassTest();

//        创建普通内部类对象，需要外部类对象去调普通内部类的构造器

        InnerClassA innerClassA = outerObj.new InnerClassA();

    }

}

```

### 静态内部类

```Java

/**

 * 静态内部类

 * 创建静态内部类对象，无需创建外部类对象。可直接创建内部类对象

 * new.外部类名.静态内部类名

 */

@Data

public class InnerClass01 {

    public int field1 = 999;

    public InnerClass01() {

        System.out.println("创建 " + this.getClass().getSimpleName() + " 对象");

        // 创建静态内部类对象

        StaticClass innerObj = new StaticClass();

        System.out.println("其内部类的 field1 字段的值为: " + innerObj.field1);

        System.out.println("其内部类的 field2 字段的值为: " + innerObj.field2);

        System.out.println("其内部类的 field3 字段的值为: " + innerObj.field3);

        System.out.println("其内部类的 field4 字段的值为: " + innerObj.field4);

    }

    static class StaticClass {

        public int field1 = 1;

        protected int field2 = 2;

        int field3 = 3;

        private int field4 = 4;

        // 静态内部类中可以定义 static 属性

        static int field5 = 5;

        public StaticClass() {

            System.out.println("创建 " + StaticClass.class.getSimpleName() + " 对象");

//            System.out.println("其外部类的 field1 字段的值为: " + field1); // 编译错误！！

        }

    }

    public static void main(String[] args) {

        // 无需依赖外部类对象，直接创建内部类对象

     InnerClass01.StaticClass staticClassObj = new InnerClass01.StaticClass();

        System.err.println(staticClassObj);

//        InnerClass01 innerClass01 = new InnerClass01();

    }

}

```

### 匿名内部类

```java

/**

 * 匿名内部类---只能写在方法中

 * 在方法参数中新建一个接口对象 / 类对象，并且实现这个接口声明 / 类中原有的方法

 * 1、直接 new 一个接口，并实现这个接口声明的方法，在这个过程其实会创建一个匿名内部类实现这个接口，并重写接口声明的方法，然后再创建一个这个匿名内部类的对象并赋值给前面的 OnClickListener 类型的引用；

 * 2、new 一个已经存在的类 / 抽象类，并且选择性的实现这个类中的一个或者多个非 final 的方法，这个过程会创建一个匿名内部类对象继承对应的类 / 抽象类，并且重写对应的方法。

 * 同样的，在匿名内部类中可以使用外部类的属性，但是外部类却不能使用匿名内部类中定义的属性，因为是匿名内部类，因此在外部类中无法获取这个类的类名，也就无法得到属性信息。

 *

 */

@Data

public class InnerClass02 {

    public int field1 = 1;

    protected int field2 = 2;

    int field3 = 3;

    private int field4 = 4;

    public InnerClass02() {

        System.out.println("创建 " + this.getClass().getSimpleName() + " 对象");

    }

    // 自定义接口

    interface OnClickListener {

        void onClick(Object obj);

    }

    interface OnClickListener02 {

        void onClick(Object obj);

    }


 

    private void anonymousClassTest() {

        // 在这个过程中会新建一个匿名内部类对象，

        // 这个匿名内部类实现了 OnClickListener 接口并重写 onClick 方法

        OnClickListener clickListener = new OnClickListener() {

            // 可以在内部类中定义属性，但是只能在当前内部类中使用，

            // 无法在外部类中使用，因为外部类无法获取当前匿名内部类的类名，

            // 也就无法创建匿名内部类的对象

            int field = 1;

            @Override

            public void onClick(Object obj) {

                System.out.println("对象 " + obj + " 被点击");

                System.out.println("其外部类的 field1 字段的值为: " + field1);

                System.out.println("其外部类的 field2 字段的值为: " + field2);

                System.out.println("其外部类的 field3 字段的值为: " + field3);

                System.out.println("其外部类的 field4 字段的值为: " + field4);

            }

        };

        // new Object() 过程会新建一个匿名内部类，继承于 Object 类，

        // 并重写了 toString() 方法

        clickListener.onClick(new Object() {  //调用匿名内部类

            @Override

            public String toString() {

                return "obj1";

            }

        });

    }

    public static void main(String[] args) {

//        创建外部类的对象

        InnerClass02 outObj = new InnerClass02();

//        用外部类去调这个属性方法

        outObj.anonymousClassTest();

    }

}

```

### 局部内部类

```java

/**

 * 局部内部类

 * 只能在当前方法中使用

 */

@Data

public class InnerClass03 {

    public int field1 = 1;

    protected int field2 = 2;

    int field3 = 3;

    private int field4 = 4;

    public InnerClass03() {

        System.out.println("创建" + this.getClass().getSimpleName() + "对象");

    }


 

    private void localInnerClassTest() {

        //局部内部类A，只能在当前方法中使用

        class A {

            // static int field = 1; // 编译错误！局部内部类中不能定义 static 字段

            //            局部内部类的构造

            public A() {

                System.out.println("创建 " + A.class.getSimpleName() + " 对象");

                System.out.println("其外部类的 field1 字段的值为: " + field1);

                System.out.println("其外部类的 field2 字段的值为: " + field2);

                System.out.println("其外部类的 field3 字段的值为: " + field3);

                System.out.println("其外部类的 field4 字段的值为: " + field4);

            }

        }

        A a = new A();

        if (true){

//            代码块中的局部内部类

//            局部内部类B 只能在当前代码块中使用

            class B{

                public B() {

                    System.out.println("创建 " + B.class.getSimpleName() + " 对象");

                    System.out.println("其外部类的 field1 字段的值为: " + field1);

                    System.out.println("其外部类的 field2 字段的值为: " + field2);

                    System.out.println("其外部类的 field3 字段的值为: " + field3);

                    System.out.println("其外部类的 field4 字段的值为: " + field4);

                }

            }

            B b = new B();

        }

//        B b1 = new B(); // 编译错误！不在类 B 的定义域内，找不到类 B

    }

    public static void main(String[] args) {

        InnerClass03 innerClass03 = new InnerClass03();

        innerClass03.localInnerClassTest();

    }

}

```


 

weixin_52489741
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Jdk1.8特性.md
09-28
Jdk1.8特性.md
jdk1.8新特性.doc
04-01
本文主要介绍了JDK1.8版本中的一些新特性，仅供参考。 jdk1.8新特性知识点： 1、Lambda表达式 2、函数式接口 3、方法引用和构造器调用 4、Stream API 5、接口中的默认方法和静态方法 6、新时间日期API
JDK1.8 新特性
赚钱养家
12-28 1226
jdk1.8新特性知识点： Lambda表达式 函数式接口 *方法引用和构造器调用 Stream API 接口中的默认方法和静态方法 新时间日期API
20，JDK1.8特性
扶墙的老汉
10-24 1858
Java8新特性简介 Java8（又称为jdk1.8）是Java语言开发的一个重要版本。Java8是Oracle公司于2014年3月发布，可以看成是自Java5以来最具革命性的版本。Java8为Java语言，编译器，类库，开发工具与JVM带来了大量的新特性。 代码更少（增加了新的语法：Lambda表达式） 强大的Stream API 速度更快 最大化减少空指针异常：Optional Nashor...
JDK1.8新特性
m0_62946761的博客
05-24 8948
jdk1.8新特性——Lambda表达式，StreamAPi，新时间类，Option，接口内默认方法和静态方法实现
【jdk1.8特性】之Function
JustryDeng
09-16 8083
笔者日常： 来吧，Function~ 相关声明： 本文按照以下顺序进行说明并给出简单的使用示例： 序号 接口 1 Function<T, R> 2 IntFunction<R> 3 DoubleFunction<R> 4 LongFunction<R> 5 ToIntFunction<T> 6 T...
JDK 1.8 新特性
yy139926的博客
05-24 1454
Java在1.8版本的时候，引入了Lambda表达式，Lambda表达式指的是应用在单一抽象方法接口环境下的一种简化定义形式，可以用于解决匿名内部类的定义复杂问题。
JDK 1.8 特性
Welcome to My blog
04-08 124
Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。 Lambda 表达式− Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。 方法引用− 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使..
java jdk 1.8特性_Java JDK 1.7 和 JDK 1.8 新特性
weixin_39574943的博客
02-16 144
引言本文主要介绍 Java JDK 中 1.7 和 1.8 的新特性。JDK 1.7 新特性1. switch可以接受String类型；public class Switch {public void test(String str) {switch (str) {case "computer":System.out.println("computer");break;case "book":Sy...
Java8(JDK1.8)新特性
热门推荐
weixin_40294256的博客
08-15 5万+
1、速度快；2、代码少、简介（新增特性:lamdba表达式）；3、强大的Stream API；4、使用并行流和串行流；5、最大化较少空指针异常Optional；其中最为核心的是Lambda表达式和Stream APILambda是一个匿名函数，我们可以将Lambda表达式理解为一段可以传递的代码（将代码像数据一样传递）。使用它可以写出简洁、灵活的代码。作为一种更紧凑的代码风格，使java语言表达能力得到提升。...
java jdk 1.8特性_Java JDK1.8新特性之四大函数式接口
weixin_26854475的博客
02-16 62
JDK 1.8的一些新特性四大核心函数式接口(Consumer、Predicate、Supplier、Function)，结合lambda表达式import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.function.Function;import java.util.fun...
JDK1.8新特性总结
零点
11-27 556
一、引言 JDK1.8出来已经一段时间了，现在1.9也已经出来了，有部分公司不太愿意升级到高版本的JDK1.8，有些项目之前使用到是低版本JDK，如果升级维护老版本项目就比较麻烦，需要连带升级其他到框架。今天抽了一段时间把这些都总结一下 二、新特性 1、关键字 default 关键字 在JDK1.8之前，项目中我们定义的接口中一般都只有抽象的方法不能有方法体，其实则不然，接口里面可以定义静态的具体...
JDK1.8压缩包下载解压即用
07-05
提供两种资源方式：（JDK1.8压缩包64位Windows版本）上面JDK1.8压缩包直接下载（解压一下就可以用），想自己下载的下方官网网址自行查找 官网下载地址：https://www.oracle.com/java/technologies/downloads/ JDK...
JDK1.8下载 : jdk_8.0.1310.11_64.zip
04-19
jdk1.8新特性: 1.Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可。 2.新增lambda表达式 3.提供函数式接口 4.Java 8 允许你使用关键字来传递方法或者构造函数引用 5.我们可以直接在...
jdk1.8新特性
03-13
JDK1.8新特性简介剖析，仅做参考，希望大家相互学习 作为Comparator 和Runnable早期的证明，在JDK中已经定义的接口恰巧作为函数接口而与lambdas表达式兼容。同样方式可以在你自己的代码中定义任何函数接口或第三方...
简单的项目部署脚本（转载）
u010230019的博客
06-09 594
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1213
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 398
修改菜品——后端Java
java.lang.reflect.Type是什么
最新发布
yuchangyuan5237的博客
06-12 372
通过 java.lang.reflect.Type 接口及其实现，Java 提供了一个强大的机制，用于在运行时检查和操作类型信息。这在编写通用库、框架和工具时特别有用，因为它允许你处理泛型类型和其他复杂类型结构。
jdk1.8特性详解
10-08
引用: JDK 1.8引入了许多新的特性，其中包括Lambda表达式、函数式接口、方法引用、Stream流等。Lambda表达式是一种简洁的写法，可以用于代替匿名内部类。函数式接口是只包含一个抽象方法的接口，可以用Lambda表达式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值