Java8的主要新特性

最新推荐文章于 2024-05-23 18:04:05 发布
最新推荐文章于 2024-05-23 18:04:05 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： javase 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56116754/article/details/131770869
版权

1、对HashMap集合的数据结构优化

原来的HashMap采用的数据结构是哈希表（数组+链表），HashMap默认大小是16，一个下标0-15的数组，往里面存储元素时，首先调用元素的hashcode（）方法，计算出哈希值，经过哈希算法找到对应的数组的索引，如果对应索引没有存放元素则直接存放，如果已经有元素了，（发生碰撞，equals方法就是碰撞时才会执行的方法）–那么调用它们的equals方法比较内容（key），如果内容一样，则后面的value值代替前者的value值；如果内容不同，则后加的放在前面，（挂在下面），形成一个链表。

这种情况下，如果链表无限下去，效率极低，碰撞避免不了

1.8之后，在数组+链表+红黑树来实现hashMap，当碰撞的元素个数大于8时或总容量大于64，会有红黑树的引入。

2、Lambda表达式

  • lambda表达式本质上是一段匿名内部类，也可以是一段可以传递的代码
  • 最直接的优点：简洁代码
  • 只有函数式接口的匿名内部类 才可以使用Lambda表达式来进行简化

函数式接口不同于普通接口，接口中只有一个抽象方法是需要我们去实现的，Lambda表达式正好是针对这个唯一的抽象方法使用

public class TreeSetTest {
    public static void main(String[] args) {
        //创建实现Comparator接口的匿名类对象，对象方法的参数和返回值类型均为Integer类型
        Comparator<Integer> cpt1 = new Comparator<Integer>() {
            //接口里有唯一方法，可以用匿名内部类来创建实现接口的类
            @Override
            public int compare(Integer o1, Integer o2) {
              //Integer中封装了比较大小的方法compare
                return Integer.compare(o1, o2);
            }
        };
/**使用lambda表达式
 *创建实现Comparator接口的类的对象，重写接口的方法
 *（x,y)实现方法参数，Integer.compare(x,y)方法实现
 * 只需要写参数名和方法实现。因为方法名唯一已经知道了
 */
       Comparator<Integer> cpt2 = (x, y) -> Integer.compare(x, y);


        //每插入一条数据，就用比较器来比较一次
      //TreeSet内部元素有序、不可重复
        TreeSet<Integer> set = new TreeSet<>(cpt1);
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(6);
        System.out.println(set);
        System.out.println("=========================");


    }
}
  • 可以自定义一个比较器，通过重写比较器的方法，来自定义比较的字段，如，自定义一个来比较学生的成绩的比较器

        //自己重写Comparator中的compare方法，变成比较学生成绩的比较器
        Comparator<Student>cs = (s1,s2)-> ((s1.grade < s2.grade) ? -1 : (s1.grade == s2.grade) ? 0 : 1);

        TreeSet<Student>treeSet = new TreeSet<>((Comparator) cs);
        treeSet.add(new Student(78));
        treeSet.add(new Student(68));
        treeSet.add(new Student(58));
        treeSet.add(new Student(88));
        for (Student student:treeSet
             ) {
            System.out.println(student);
        }

3、Default关键字

  • 在JDK1.8之前，default一直是switch用于条件分值中默认项的一个关键字。但是在JDK1.8之后，它被赋予了新的功能，它可以被用在接口中，定义非抽象方法。
  • JDK1.8之后，接口中声明的方法就并不一定是抽象方法了 ，现在经过default修饰的方法可以有了方法体了。
interface TestInterface {
    //此处默认会是public static final修饰的，如果你修改，会有错误提示
    String test= "test";
     static void test1(){//此处有方法体
     System.out.println("我是interface中的static修饰的方法体");
	 }
	 default void test2(){ //此处有方法体
        System.out.println("我是interface中的default修饰的方法体");
    }
 }

 public class TestInterface8 implements TestInterface{//一个类实现接口，相当于继承这个方法里的default方法
     public static void  main(String[] args)
	{
        //接口中的方法不一定都是abstract
		 TestInterface8 a=new TestInterface8();
         //继承接口中的default方法test2
		 a.test2();
         //接口里的static方法可以直接类名.方法来调用
		 TestInterface.test1();
    }
}

  • 如上代码，jdk1.8之后，接口中的方法不再都是抽象方法，接口中的方法可以通过 static或者defalut修饰，并且可以拥有方法体。通过static修饰的方法，可以有方法体，实现接口的类，可以直接通过接口类.方法来调用 ；通default修饰的方法，可以有方法体，实现接口的类，可通过创建接口类的对象，通过对象调用default方法

  • 这是JDK8中为了加强接口的能力，使得接口可以存在具体的方法，前提是方法需要被default或static 关键字所修饰。这样做的好处是接口的每个实现类如果都想要相同的功能，就不需要重复代码，而是在接口进行定义即可 。默认方法在子类也可以被重写。

  • interface 的设计初衷是面向抽象，提高扩展性。这也留有一点遗憾，Interface 修改的时候，实现它的类也必须跟着改。于是1.8之后，interface中修改方法，可以加static或default修饰，这样子类不用一定要实现，并且可以直接调用

4、Stream

  • Stream是JDK 8 中最优秀的设计，集合的操作中提供了更加便捷的方式，这里的Stream和I/O流不同，它更像具有Iterable的集合类，但行为和集合类又有所不同。
  • Stream是对 Java 集合运算和表达的高阶抽象。将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
  • 使用场景：适用于集合操作超过两个步骤 ；任务较重，注重效能，希望并发执行；函数式编程的编码等场景中。Stream 存在于 java.util.stream 包中，

Stream的创建

//通过集合创建
List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();

//通过数组创建
int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

//通过Stream的静态方法: of(),iterate(),generate()
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);

Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

遍历/匹配

  List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

        // 遍历输出符合条件的元素。 遍历输出x>6的元素
        list.stream().filter(x -> x > 6).forEach(System.out::println);
        // 匹配第一个
        Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
        // 是否包含符合特定条件的元素
        boolean anyMatch = list.stream().anyMatch(x -> x > 6);

筛选filter

List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
//筛选大于6的元素并打印出来
 list.stream()
   .filter(x->x>6)
   .forEach(System.out::println);

5、函数式接口

  • 函数式接口是仅且只能包含一个抽象的方法 的接口,每一个该类型的lambda的表达式都会匹配到这个抽象方法上,jdk1.8提供**@FunctionalInterface**注解来定义函数式接口 ，如：
/**
 * 函数式接口:只包含一个抽象方法的接口，称为函数式接口
 * 通过 Lambda 表达式来创建该接口的对象
 * 可以通过@FunctionalInterface注解检查它是否是一个函数式接口,也可以省略
 */
@FunctionalInterface
interface Haha {
    public int test(int a, int b);
}

public class FunInter {
    public static void main(String[] args) {
/**
 1.调用Haha接口的test方法
 2.该方法用lambda表达式实现test方法
 3.在lambda表达式中(a,b)表示方法的参数，a+b为方法的实现
 */
       Haha haha = (a, b) -> a + b;
       System.out.println(haha.test(2, 5));
      
	   //System.out.println(((Haha)(a, b) -> a + b).test(2, 5));

    }
}

6、方法与构造方法引用

  • jdk1.8提供一种方式，通过::关键字来传递方法或者引用,方法引用分为三种：
    • 静态方法引用，通过类名：：静态方法名，如 Integer :: parseInt
    • 实例方法引用，通过实例对象：：实例方法，如 str::substring
    • 构造方法引用，通过类名：：new ，如User：：new
//Integer类
public final class Integer {
    public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }
}


//User类
public class User {
    private String username;
    private Integer age;
    public User() {
    }
    public User(String username, Integer age) {
        this.username = username;
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
    // Getter&Setter
} 


/*
三种::引用方式

*/
public static void main(String[] args) {
    // 使用双冒号::来构造静态函数引用 。创建实现Function接口的对象
  //通过类名：：静态方法名
    Function<String, Integer> fun = Integer::parseInt;
    Integer value = fun.apply("123");
    System.out.println(value);
 
    // 使用双冒号::来构造非静态函数引用
  //通过 实例对象名::实例方法名  创建实现Function接口的对象
    String content = "Hello JDK8";
    Function<Integer, String> func = content::substring;
    String result = func.apply(1);
    System.out.println(result);
 
    // 构造函数引用
  //通过  类名::new   创建实现 BiFunction接口的对象
    BiFunction<String, Integer, User> biFunction = User::new;
    User user = biFunction.apply("mengday", 28);
    System.out.println(user.toString());
 
    // 函数引用也是一种函数式接口，所以也可以将函数引用作为方法的参数
    sayHello(String::toUpperCase, "hello");
}
 
// 方法有两个参数，一个是
private static void sayHello(Function<String, String> func, String parameter){
    String result = func.apply(parameter);
    System.out.println(result);
}
  • 目前为止，有三种创建函数式接口对象的方式，匿名内部类创建，lambda表达式创建，方法的引用
package day01;


class Person {
    String firstName;
    String lastName;
    Person() {
        System.out.println("Person()被调用");
    }
    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
        System.out.println("Person(String firstName, String lastName)被调用");
        System.out.println("firstName =" + firstName);
        System.out.println("lastName =" + lastName);
    }
}

/**
 * PersonFactory接口的方法形参类型为String类型，返回值为Person类型
 */
interface PersonFactory<String, Person> {

    public Person create(String firstName, String lastName);
}

public class PerFa {
    public static void main(String[] args) {
        System.out.println("使用匿名类创建接口的对象");
        PersonFactory<String, Person> personFactory1 = new PersonFactory<String, Person>() {
            @Override
            public Person create(String firstName, String lastName) {
                return new Person(firstName, lastName);
            }
        };
        Person person1 = personFactory1.create("li", "sa");
        System.out.println(person1);
      
      
      
      
        System.out.println("*****************************");
        System.out.println("使用lambda表达式创建接口的对象");
        PersonFactory<String, Person> personFactory2 =
                (firstName, lastName) -> new Person(firstName, lastName);
        Person person2 = personFactory2.create("zhang", "san");
        System.out.println(person2);
      
      
      
      
        System.out.println("*****************************");
        /**
         使用构造方法引用创建接口的对象
         使用 Person::new 来获取Person类构造函数的引用，(new Person)
         Java编译器会自动根据PersonFactory.create方法的签名来选择合适的构造函数
         */
        System.out.println("使用构造方法引用创建接口的对象");
      	//根据接口的方法的参数类型来自动选择合适的构造函数
        PersonFactory<String, Person> personFactory3 = Person::new;
        Person person3 = personFactory3.create("Peter", "Parker");
        System.out.println(person3);

    }
}

7、Date-Time API

  • 这是对java.util.Date强有力的补充，解决了Date类的大部分痛点

非线程安全

时区处理麻烦

各种格式化、和时间计算繁琐

设计有缺陷，Date类同时包含日期和时间；还有一个java.sql.Date，容易混淆

  • java.util.Date 既包含日期又包含时间，而java.time把它们进行了分离。java.time主要类
LocalDateTime.class //日期+时间 format: yyyy-MM-ddTHH:mm:ss.SSS
LocalDate.class //日期 format: yyyy-MM-dd
LocalTime.class //时间 format: HH:mm:ss
  • 1.8之后的格式化
public void newFormat(){
    //format yyyy-MM-dd  日期
    LocalDate date = LocalDate.now();
    System.out.println(String.format("date format : %s", date));

    //format HH:mm:ss   时间
    LocalTime time = LocalTime.now().withNano(0);
    System.out.println(String.format("time format : %s", time));

    //format yyyy-MM-dd HH:mm:ss  时间+日期
    LocalDateTime dateTime = LocalDateTime.now();
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    String dateTimeStr = dateTime.format(dateTimeFormatter);
    System.out.println(String.format("dateTime format : %s", dateTimeStr));
}
  • 1.8之后的字符串转日期格式
LocalDate date = LocalDate.of(2021, 1, 26);
LocalDate.parse("2021-01-26");

LocalDateTime dateTime = LocalDateTime.of(2021, 1, 26, 12, 12, 22);
LocalDateTime.parse("2021-01-26 12:12:22");

LocalTime time = LocalTime.of(12, 12, 22);
LocalTime.parse("12:12:22");
  • 1.8之后获取指定日期
public void getDayNew() {
    LocalDate today = LocalDate.now();
    //获取当前月第一天：
    LocalDate firstDayOfThisMonth = today.with(TemporalAdjusters.firstDayOfMonth());
    // 取本月最后一天
    LocalDate lastDayOfThisMonth = today.with(TemporalAdjusters.lastDayOfMonth());
    //取下一天：
    LocalDate nextDay = lastDayOfThisMonth.plusDays(1);
    //当年最后一天
    LocalDate lastday = today.with(TemporalAdjusters.lastDayOfYear());
    //2021年最后一个周日
    LocalDate lastMondayOf2021 = LocalDate.parse("2021-12-31").with(TemporalAdjusters.lastInMonth(DayOfWeek.SUNDAY));
}
  • JDBC和java8

Date----> LocalDate

Time----> LocalTime

Timestamp---->LocalDateTime

Zero摄氏度
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java8新特性（简述十大新特性）
ywl470812087的博客
12-23 3380
你真的开始用JDK8了吗？如果你没有用上一些新特性，请别说自己使用了Java8。Java 8可谓是自Java 5以来最具革命性的版本了，她在语言、编译器、类库、开发工具以及Java虚拟机等方面都带来了不少新特性。我们来一一回顾一下这些特性。
Java 8 新特性
m0_52581288的博客
08-05 1383
Java 8 新特性快速入门，有这一篇就够了
Java8 有什么新特性
最新发布
weixin_44714029的博客
05-23 293
Java8 的新特性
简单使用lambda表达式
qq_44716544的博客
07-24 810
什么是lambda表达式？ Lambda 是一个 匿名函数，我们可以把 Lambda 表达式理解为是 一段可以传递的代码（将代码像数据一样进行传递）。 使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升 Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或 箭 头操作符。 它将 Lambda 分为两个部分：左侧：指定了 Lambda 表达式需要的参 参
Java8特性大全
Mr. David 专栏
07-05 1545
为了方便对收集操作的理解，方便读者掌握收集操作，将收集分为普通收集和高级收集。方法引用是对特殊 Lambda 表达式的一种简化写法，当 Lambda 体中只调用一个方法，此方法满足函数式接口规范，此时可以使用::方法引用语法。从语法表现力角度来讲，方法引用 > Lambda表达式 > 匿名内部类，方法引用是高阶版的 Lambda 表达式，语言表达更为简洁，强烈推荐使用。传统的Collectors类中的排序支持 List 实现类中的一部分排序，使用 stream 排序，能够覆盖所有的 List 实现类。
java8新特性Lambda和Stream以及函数式接口等新特性介绍
qq_36595761的博客
10-09 2717
主要内容 1.Lambda 表达式 2.函数式接口 3.方法引用与构造器引用 4.Stream API 5.接口中的默认方法与静态方法 6.新时间日期API 7.其他新特性 Java 8新特性简介 速度更快 速度更快 代码更少（增加了新的语法Lambda 表达式） 强大的Stream API 便于并行 最大化减少空指针异常Optional Nashorn 引擎，允许在 JVM 上运行 JS 应用 其中最为核心的为Lambda 表达式与Stream API 并行流与串行流   并行流就是把一个内容分成多个
java8新特性总结
CUITAO2305532402的博客
06-11 2822
Java中的Lambda表达式是JDK8中的一种新特性，它允许我们将一段代码（这段代码可以理解为一个接口的实现）当成参数传递给某个方法，然后进行业务处理，这种方式更像是一种函数式编程风格，可以让代码结构更简洁，开发效率更高。比较让人容易迷乱的是lambda的几个简化写法。后面会一一细说。lambda的学习点也就两个，一个是把一点代码作为参数传递，一个是它的简化写法。
java8的下载与安装(网上教程的安装方法)
热门推荐
code猫大叔
12-10 13万+
1 首先是进入java的下载页面 Java Downloads | Oraclehttps://www.oracle.com/java/technologies/downloads/ 然后下拉，选java8 点击java8之后，会出现 这时我们选择windows（当然，以你的系统环境而定） 然后 基本上就可以下载了， 为什么是基本上，因为，需要你注册一个账户，注册完，就可以下载了 //----------------------------------------- ..
Java 8的八个新特性
chszs的专栏
11-24 9402
Java 8的八个新特性1、接口的默认方法和静态方法.Java 8在接口方面引入了新特性。Java 8版之前，接口只有抽象方法，而在Java 8，为接口新增了两种类型的方法。第一种是默认方法。此方法使用了default关键字修饰方法名。实际上接口不包含任何实现的方法，而在Java 8中，可以通过使用default关键字来添加默认的方法实现。接口的实现类可以直接使用这些默认的方法，同时还可以重写默认的方法，这不
java8新特性
12-26
主要是对java8新特性的一些讲解，在ppt中，有lambda表达式，有Stream等知识点
Java8 新特性
04-27
以下是一些主要的Java8新特性详解： 1. **Lambda表达式**：Lambda表达式是Java8中最显著的新特性，它为Java引入了函数式编程的概念。Lambda允许将函数作为一个方法参数，或者存储在变量中。这种简洁的语法让多线程...
详细分析JAVA8新特性 Base64
08-18
详细分析JAVA8新特性Base64 JAVA8新特性Base64是JAVA8中一个非常重要的新特性，它提供了一种简洁易用的Base64编码和解码方式。在本文中，我们将详细介绍JAVA8新特性Base64的相关知识点，并对其进行深入分析。 ...
java 8 教程（基础篇）
qq_35414977的博客
01-28 1543
集合——有时称为容器——是一个对象，它将多个元素组合成一个单元。集合用于存储、检索、操作和通信聚合数据。集合框架表示和操作集合的统一体系结构。组成接口表示集合的抽象数据类型。接口允许对集合进行独立于其表示细节的操作。在面向对象语言中，接口通常形成层次结构。实现是集合接口的具体实现。本质上，它们是可重用的数据结构。算法这些方法在实现集合接口的对象上执行有用的计算，比如搜索和排序。这些算法被认为是多态的:也就是说，相同的方法可以用于适当的集合接口的许多不同实现。本质上，算法是可重用的功能。
Java 8中的一些主要特性及其详细使用方法
hackerlee
07-13 820
Java 8引入了全新的日期和时间 API，位于 java.time 包下，提供了更好的日期、时间处理和操作的方式。Java 8 中的这些新特性使得 Java 编程更加灵活、高效和易读，提供了更好的工具和功能来应对不同的开发需求。Java 8 中的这些新特性使得 Java 编程更加强大和便利，提供了更多的语言特性和工具来提升开发效率和代码质量。Java 8 允许接口中定义默认方法，即在接口中可以提供方法的默认实现。这样做的目的是为了在接口的演化过程中能够向已有的实现提供新的方法，而不会破坏实现的兼容性。
全面讲解什么是Java8新特性，内附大量实例，认真阅读，没有难点！
m0_46638350的博客
02-18 1431
函数式接口：只包含一个抽象方法的接口，称为函数式接口，并且可以使用lambda表达式来创建该接口的对象，可以在任意函数式接口上使用@FunctionalInterface注解，来检测它是否是符合函数式接口。注：通过 default 关键字这个新特性，可以非常方便地对之前的接口做拓展，而此接口的实现类不必做任何改动，减少了耦合性。Java8以前的版本使用注解有一个限制是相同的注解在同一位置只能使用一次，不能使用多次。实际上，重复注解不是一个语言上的改变，只是编译器层面的改动，技术层面仍然是一样的。
Java8新特性总结学习
小飞技术
07-11 281
文章目录Lambda：为什么使用Lambda表达式 ?Lambda表达式语法 ?什么是函数式接口 ？Lambda 表达式的基本语法：Lambda 四大内置核心函数式接口：Consumer：消费型接口:Supplier：供给型接口:Function: 函数型接口:Predicate：断言型接口:方法引用与构造器引用:创建 Stream:Stream_筛选与切片emps:filter--接收Lambd...
Java8新特性详解史上最“不”详细（持续更新中）
罗宸熙的博客
07-15 63
Java 8引入了许多令人兴奋的新特性，包括Lambda表达式、函数式接口、Stream API、默认方法、方法引用和Optional类。Lambda表达式提供了更简洁的编写匿名函数的方式，Stream API简化了集合数据的处理，函数式接口和默认方法支持函数式编程，方法引用简化了Lambda表达式的写法，Optional类处理可能的空值情况。这些特性使得Java 8更加强大和现代化。
JAVA从入门到精通------基础篇------java8新特性
weixin_56777219的博客
02-11 1547
JAVA从入门到精通------基础篇
Java9都快发布了，Java8的十大新特性你了解多少呢？
weixin_30784141的博客
08-03 281
Java 9预计将于今年9月份发布，这是否会是一次里程碑式的版本，我们拭目以待。今天，我们先来复习一下2014年发布的Java 8的十大新特性。 Java 8可谓是自Java 5以来最具革命性的版本了，她在语言、编译器、类库、开发工具以及Java虚拟机等方面都带来了不少新特性。我们来一一回顾一下这些特性。 一、Lambda表达式 Lambda表达式可以说是Java 8最大的卖点，她将函数...
java 8新特性
07-27
回答: Java 8是Java语言开发的一个主要版本，于2014年3月发布。它为Java语言、编译器、类库、开发工具与JVM带来了许多新特性。其中最具革命性的特性之一是引入了Stream API（java.util.stream），它将真正的函数式编程风格引入到Java中。Stream API可以极大提高Java程序员的生产力，让他们编写高效、干净、简洁的代码。此外，Java 8还做出了调整以支持更广泛的技术要求，不仅支持面向对象编程（OOP），还支持面向函数编程（OOF）。\[1\]\[2\]\[3\] #### 引用[.reference_title] - *1* *2* *3* [Java8的新特性](https://blog.csdn.net/weixin_44065652/article/details/120660479)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zero摄氏度

感谢鼓励！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值