Java8新特性_Stream_排序

最新推荐文章于 2025-10-30 17:30:43 发布
原创 最新推荐文章于 2025-10-30 17:30:43 发布 · 807 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#其他 #java #开发语言

本文详细介绍了Java Stream API的使用，包括过滤、映射、短路操作、去重、排序等，并展示了如何在Employee类中实现自然排序。通过实例展示了如何根据年龄和薪水对员工列表进行排序，同时探讨了字符串比较的Unicode规则。 

package com.zs.boot.controller;

public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;
	private Status status;

	public Employee() {
	}

	public Employee(String name) {
		this.name = name;
	}

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

	public Employee(int id, String name, int age, double salary) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Employee(int id, String name, int age, double salary, Status status) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.status = status;
	}

	public Employee(String name, int age, double salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Status getStatus() {
		return status;
	}

	public void setStatus(Status status) {
		this.status = status;
	}

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String show() {
		return "测试方法引用！";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
				+ "]";
	}

	public enum Status {
		FREE, BUSY, VOCATION;
	}

}

package com.zs.boot.controller;

import org.junit.Test;

import java.util.*;
import java.util.stream.Stream;

public class TestStream2API {

    List<Employee> employees = Arrays.asList(
            new Employee("刘德华",48,8000),
            new Employee("张学友",28,8500),
            new Employee("黎明",45,6500),
            new Employee("黎明",45,6500),
            new Employee("郭富城",51,5500));

    //过滤出年龄大于35
    //内部迭代：迭代操作由StreamAPI完成
    @Test
    public void test1(){
        //中间操作，不会执行任何操作
        Stream<Employee> s = employees.stream().filter(e -> e.getAge()>35);

        /*
        s.forEach(System.out::println);这样写会打印对象所有信息，不会只打印姓名，而我只打印姓名
        可以参考这样写Stream<String> namesStream = employees.stream().map(Employee::getName);
        Stream<String> namesStream  =  s.map(employees -> employees.getName());//用Employee::getName更简洁
        namesStream.forEach(System.out::println);
        即：
        employees.stream().filter(e -> e.getAge()>35).map(Employee::getName).forEach(System.out::println);
        */
        //中间操作后必须加终止操作才执行
        s.forEach((str) -> System.out.println(str.getName()));
        /*
        刘德华
        黎明
        郭富城
        */

    }

    //外部迭代
    @Test
    public void test2(){
        Iterator<Employee> it = employees.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

    @Test
    public void test3(){
        /*Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
        Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
        Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
        employees.stream().filter(e -> e.getSalary()>6000).limit(3).forEach(System.out::println);

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

        /*短路！
        Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
        短路！
        Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]*/
        //找到满足条件的两条数据后，后续的迭代操作就不再进行了
        employees.stream().filter(e -> {
            System.out.println("短路！");
            return e.getSalary()>6000;
        }).limit(2).forEach(System.out::println);
    }

    /*Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
    //跳过前两个
    @Test
    public void test4(){
        employees.stream().filter(e -> e.getSalary()>6000).skip(2).forEach(System.out::println);
    }

    /*Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
    Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
    Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
    //去重，注意要去实体类中重写hashcode和equals
    @Test
    public void test5(){
        employees.stream().filter(e -> e.getSalary()>6000).distinct().forEach(System.out::println);
    }

    //==================================================================================
    /*
    AA
    BB
    CC
    DD
    */
    @Test
    public void test6(){
        List<String> list = Arrays.asList("aa","bb","cc","dd");
        list.stream().map(str -> str.toUpperCase(Locale.ROOT)).forEach(System.out::println);

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

        //取出员工姓名
        employees.stream().map(e -> e.getName()).forEach(System.out::println);
        //等效写法
        employees.stream().map(Employee::getName).forEach(System.out::println);

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


        /*a
        a
        b
        b
        c
        c
        d
        d*/
        //Stream<Stream<Character>> stream = list.stream().map(s ->filterCharacter(s));
        //等效写法
        Stream<Stream<Character>> stream = list.stream().map(TestStream2API::filterCharacter);
        stream.forEach(sm -> sm.forEach(
                System.out::println
        ));

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

        /*a
        a
        b
        b
        c
        c
        d
        d*/
        Stream<Character> stream1 = list.stream().flatMap(TestStream2API::filterCharacter);
        stream1.forEach(
                System.out::println
        );

    }

    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();
        for (Character ch: str.toCharArray()) {
            list.add(ch);
        }
        return list.stream();
    }


    //==================================================================================

    /**
     * 排序
     * sorted()------自然排序Comparable
     * sorted(Comparator com)------定制排序Comparator
     */
    @Test
    public void test7(){
        List<String> list = Arrays.asList("cc","aa","dd","bb");
        list.stream().sorted().forEach(System.out::println);

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

        //定制排序
        employees.stream().sorted((e1,e2) -> {
            if (String.valueOf(e1.getAge()).equals(e2.getAge())){
                return e1.getName().compareTo(e2.getName());
            }else{
                //废弃return String.valueOf(e1.getAge()).compareTo(String.valueOf(e2.getAge()));
                //age是int类型，还是用Integer
                return  Integer.valueOf(e1.getAge()).compareTo(Integer.valueOf(e2.getAge()));
                //如果要年龄从大到小排序
                //return -String.valueOf(e1.getAge()).compareTo(String.valueOf(e2.getAge()));
            }
        }).forEach(System.out::println);

        //不用lambda，用过去传统的写法也可以
        /*employees.stream().sorted(new Comparator<Employee>() {
              @Override
              public int compare(Employee e1, Employee e2) {
                  if(String.valueOf(e1.getAge()).equals(e2.getAge())){
                      return e1.getName().compareTo(e2.getName());
                  }else{
                      return String.valueOf(e1.getAge()).compareTo(String.valueOf(e2.getAge()));
                  }
              }
          }
        ).forEach(System.out::println);*/

        /*Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
        Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]
        Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]
        Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
        Employee [id=0, name=郭富城, age=51, salary=5500.0, status=null]*/
    }



}

拓展：

如果Employee implements Comparable<Employee>

重写了compareTo方法，那就可以直接自然排序了

employees.stream().sorted().forEach(System.out::println);

package com.zs.boot.controller;

public class Employee implements Comparable<Employee>{

	private int id;
	private String name;
	private int age;
	private double salary;
	private Status status;

	public Employee() {
	}

	public Employee(String name) {
		this.name = name;
	}

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

	public Employee(int id, String name, int age, double salary) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Employee(String name, int age, double salary, Status status) {
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.status = status;
	}

	public Employee(String name, int age, double salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Status getStatus() {
		return status;
	}

	public void setStatus(Status status) {
		this.status = status;
	}

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String show() {
		return "测试方法引用！";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
				+ "]";
	}

    /*
    重写compareTo()方法是实现Comparable接口的使用（自然排序）规则：
    如果当前对象this大于形参对象obj，则返回正整数，
    如果当前对象this小于形参对象obj,则返回负整数,
    如果当前对象this等于形参对象obj,则返回零。*/

    //重写compareTo
    @Override
    public int compareTo(Employee o) {
        
        /*if(String.valueOf(this.getAge()).equals(o.getAge())){
            return this.getName().compareTo(o.getName());
        }else{
            //age是int,以后都改用Integer.compareTo
            //废弃return String.valueOf(this.getAge()).compareTo(String.valueOf(o.getAge()));
            return  Integer.valueOf(this.getAge()).compareTo(Integer.valueOf(o.getAge()));
        }*/
        //这种写法和上面等效
        if(this.getAge() > o.getAge()){
            return 1;
        }else if(this.getAge() < o.getAge()){
            return -1;
        }else{//如果年龄相等，比较姓名
            return this.getName().compareTo(o.getName());
        }
    }

    /*参考例子
    public int compareTo(Person p) {
		if(this.score>p.getScore()) {
			return 1;
		}else if(this.score<p.getScore()) {
			return -1;
		}else {//分数一样比较年龄
			if(this.age>p.getAge()) {
				return 1;
			}else if(this.age<p.getAge()) {
				return -1;
			}else {//年龄一样，比较姓名
				return this.name.compareTo(p.getName());
			}
		}	
	}*/


	public enum Status {
		FREE, BUSY, VOCATION;
	}



}

package com.zs.boot.controller;

import org.junit.Test;

import java.util.*;
import java.util.stream.Stream;

public class TestStream2API {

    List<Employee> employees = Arrays.asList(
            new Employee("刘德华",48,8000),
            new Employee("张学友",28,8500),
            new Employee("黎明",45,6500),
            new Employee("黎明",45,6500),
            new Employee("郭富城",51,5500));


    /**
     * 排序
     * sorted()------自然排序Comparable
     * sorted(Comparator com)------定制排序Comparator
     */
    @Test
    public void test7(){

        /*如果Employee implements Comparable<Employee>
        重写了compareTo方法，可以直接employees.stream().sorted().forEach(System.out::println);*/
        /*
        @Override
        public int compareTo(Employee o) {
            if(String.valueOf(this.getAge()).equals(o.getAge())){
                return this.getName().compareTo(o.getName());
            }else{
                //age是int,用Integer.compareTo
                return String.valueOf(this.getAge()).compareTo(String.valueOf(o.getAge()));
            }
        }
        */


        /*Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
        Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]
        Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]
        Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
        Employee [id=0, name=郭富城, age=51, salary=5500.0, status=null]*/
        employees.stream().sorted().forEach(System.out::println);
        

        /*
        28
        45
        48
        51
        */
        Stream list = employees.stream().sorted().map(Employee::getAge);
        list.forEach(System.out::println);
    }



}

关于中文字符串是怎么比较大小的？

中文是按照Unicode编码比较的

中文字符串是怎么比较大小的？_摆渡人gx-优快云博客

/**
 * 字符串比较案例
 */
public class StringComparisonDemo {

    public static void main(String[] args) {
        String foo = "ABC";

        // 前面和后面每个字符完全一样，返回 0
        String bar01 = "ABC";
        System.out.println(foo.compareTo(bar01));

        // 前面每个字符完全一样，返回：后面就是字符串长度差
        String bar02 = "ABCD";
        String bar03 = "ABCDE";
        System.out.println(foo.compareTo(bar02)); // -1 (前面相等,foo 长度小 1)
        System.out.println(foo.compareTo(bar03)); // -2 (前面相等,foo 长度小 2)

        // 前面每个字符不完全一样，返回：出现不一样的字符 ASCII 差
        String bar04 = "ABD";
        String bar05 = "aABCD";
        System.out.println(foo.compareTo(bar04)); // -1  (foo 的 'C' 字符 ASCII 码值为 67，bar04 的 'D' 字符 ASCII 码值为 68。返回 67 - 68 = -1)
        System.out.println(foo.compareTo(bar05)); // -32 (foo 的 'A' 字符 ASCII 码值为 65，bar04 的 'a' 字符 ASCII 码值为 97。返回 65 - 97 = -32)

        String bysocket01 = "泥瓦匠";
        String bysocket02 = "瓦匠";
        System.out.println(bysocket01.compareTo(bysocket02));// -2049 （泥 和 瓦的 Unicode 差值）
    }
}

原文链接：https://blog.youkuaiyun.com/weixin_41922289/article/details/90463971

拓展：age是int类型，以后都改用

Integer.valueOf(e1.getAge()).compareTo(Integer.valueOf(e2.getAge()));

不要使用String.valueOf(this.getAge()).compareTo(String.valueOf(o.getAge()));

employees.stream().sorted( (e1,e2) -> {
            //方法1：
            /*int ageValue = Integer.compare(e1.getAge(),e2.getAge());
            if(ageValue != 0){
                return ageValue;
            }else{
                //按照薪水从小到大
                return Double.compare(e1.getSalary(),e2.getSalary());
                //按照薪水从大到小
                //return -Double.compare(e1.getSalary(),e2.getSalary());
            }*/

            //方法2：用大于>，小于<
            /*if(e1.getAge() > e2.getAge()){
                return 1;
            }else if(e1.getAge() < e2.getAge()){
                return -1;
            }else{//按照薪水从小到大
                return Double.compare(e1.getSalary(),e2.getSalary());
            }*/
            
            //方法3：
            //等效代码
            if(String.valueOf(e1.getAge()).equals(String.valueOf(e2.getAge()))){
                return Double.compare(e1.getSalary(),e2.getSalary());
            }else{
                //return Integer.compare(e1.getAge(),e2.getAge());
                //或者用compareTo，点进去看源码，也就是调用上面的Integer.compare
                /*public int compareTo(Integer anotherInteger) {
                    return compare(this.value, anotherInteger.value);
                }
                public static int compare(int x, int y) {
                    return (x < y) ? -1 : ((x == y) ? 0 : 1);
                }*/
                return  Integer.valueOf(e1.getAge()).compareTo(Integer.valueOf(e2.getAge()));
            }

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

java.lang.String.compareTo() 方法比较两个字符串的字典。比较是基于字符串中的每个字符的Unicode值。此String对象表示的字符序列的参数字符串表示的字符序列进行比较字典. 其结果是负的整数，如果此String对象字典前面的参数字符串 其结果是一个正整数，如果此String对象字典如下的参数字符串 结果是零，如果两个字符串相等，CompareTo返回0时，equal（Object）方法将返回true。

java.lang.Integer.compareTo() 方法比较两个Integer对象的数字. 此方法如果这个整数是相等于的参数整数返回的值为0，如果这个整数数值小于参数整数则返回小于0的值，如果这个整数数值大于该参数的整数返回一个大于0的值.

Java中 List 集合，通过 Stream 流进行排序总结
KevinChen2019的博客
03-25 5483
【代码】Java中 List 集合，通过 Stream 流进行排序总结。
Java8 使用 stream().sorted()对List集合进行排序
LuckyTHP
03-05 2905
集合对象以学生类（）为例，有学生的基本信息，包括：姓名，性别，年龄，身高，生日几项。使用stream().sorted()进行排序，需要该类实现Comparable接口，该接口只有一个方法需要实现，如下：Java 关于重写compareTo方法//名称 private String name;//性别 true男 false女 private Boolean gender;//年龄 private Integer age;//身高 private Double height;
【Java 8 Stream排序进阶指南】：thenComparing高效排序技巧全解析
最新发布
CodePulse的博客
10-30 816
掌握Java 8 Stream API 排序 thenComparing，轻松实现多字段排序。本文详解thenComparing在复合条件排序中的应用，提升代码可读性与性能，适用于集合数据精细化处理场景，值得收藏。
List使用Stream按一个字段排序、分页、多级排序
bobo_bc的博客
08-08 3988
实际应用场景是接的实时数据，数据量大概有3600条，返回给客户端还需要进行排序、分页 注意点： 对于map中的排序key对应的value如果是字符串类型的数字，需要转换成数字类型（如BigDecimal、Integer）再排序，对于字符串类型的数字，是达不到对数字排序的效果的 Comparator.comparing(value)，value不能为null，会报空指针异常，这里的处理是使用st...
TreeSet集合，可排序的集合
Jerry的博客
05-29 447
导入implements  Comparable{ public int compareTo(type  o){ return(age-o.age)*5000+name.compareTo(o.name); //age，name的位置和升降序有关。5000是权重，不影响结果 } }  方法比较两个字符串的字典。比较是基于字符串中的每个字符的Unicode值。此String对象表示的字符序
Stream 排序
LYX3693的博客
07-04 1万+
Comparator.comparing(类::属性一,Comparator.reverseOrder())现有一个类test 有两个属性:state 状态 time 时间,需要状态顺序且时间倒序。2是直接进行排序,很多人会混淆导致理解出错,2更好理解,建议使用。有时候数据库会有一些错误数据，但是又要求程序不能报错，这怎么办呢？Comparator.comparing(类::属性一).1 是得到排序结果后再排序,1.含空值的正序（升序）排序(按创建时间排序)两种排序是完全不一样的,一定要区分开来。
Java8Test.java_java8_almosttog_stream流_
09-29
Java 8是Java语言的一个重要版本，引入了许多新特性，其中Stream API是其最显著的改进之一。Stream API提供了一种新的数据处理方式，使得在集合上进行操作更加简洁、高效。本文将深入探讨Java 8 Stream API的基础...
包括_基础数据结构leetcode基本搜索算法基本排序算法Java8_stream_java_basic.zip
09-26
本压缩包“java_basic-master”以Java语言为核心，涵盖了基础数据结构、leetcode经典搜索算法、排序算法以及Java 8的stream API等内容，这四个方面是计算机科学教育和软件开发实践中的重要组成部分。 基础数据结构...
Java 入门指南：Java 8 新特性 —— Stream 流
热带鱼的技术博客
09-21 2293
Java Stream 是 Java 8 引入的一个新的API，它提供了一种函数式编程的方式来处理集合数据。Stream 可以看作是一系列支持高效的、函数式操作的元素序列。 通过使用Stream，可以对集合进行 过滤、映射、排序、查找 等操作，而不需要显示地使用循环或者迭代器。Stream API 使用一种类似于 SQL 查询的方式来操作数据，这样可以使代码更加简洁、可读性更强。
java8新特性将List中按指定属性排序过滤重复数据的方法
08-25
Java 8 新特性将 List 中按指定属性排序过滤重复数据的方法 Java 8 新特性将 List 中按指定属性排序过滤重复数据的方法是 Java 8 中一个非常有用的功能，它可以帮助开发者快速地对 List 中的数据进行排序和过滤，以...
681.679.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：排序(681).rar
11-09
在Java编程语言中，动态代理和Java 8的新特性，如Stream API，是现代Java开发者必须掌握的关键概念。本教程将深入探讨这两个主题，特别是Stream API的中间操作——排序。 首先，让我们了解一下Java中的动态代理。...
stream排序
热门推荐
qq_39408587的博客
12-28 6万+
stream如何排序？ 使用stream中sorted方法 怎么使用？ 1：创建实体类。2：创建list。3：用list.stream().sorted(); 如图所示： List<Test> list = new ArrayList<>(); Test test = new Test(); test.setName("张三"); test.setAge(18); test.setState(1);
Stream 排序
SuperWhitePoplar的博客
07-30 1506
List&lt;OmAppDeployTaskView&gt; stream = page.stream().sorted(Comparator.comparing(OmAppDeployTaskView::getInsertTime).reversed()).collect(Collectors.toList());
fastjson java 字段排序_java stream sorted 多字段排序
weixin_36486007的博客
01-14 317
package com.qimh.springbootfiledemo;import com.alibaba.fastjson.JSON;import com.google.common.collect.Lists;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Comparato...
stream流排序（升序降序）
li836779537的博客
12-26 6998
【代码】stream流排序（升序降序）
集合list排序，普通排序，stream(单属性、多属性)排序
dmjxsy的博客
02-10 1万+
集合list排序，普通排序，stream(单属性、多属性)排序
在Java中用stream()对数据排序
liu_wen_tao的博客
12-28 401
【代码】【无标题】
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ZHOU_VIP

您的鼓励将是我创作最大的动力！

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

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

打赏作者

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

抵扣说明：

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

余额充值