Java 8 (4/6篇) - Stream API 流操作集合

已于 2022-06-27 21:12:10 修改
阅读量731 收藏 1
点赞数 1
分类专栏： Java 8 文章标签： java
于 2021-09-09 14:45:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HugMua/article/details/120144528
版权

Stream是对集合(Collection)对象功能的增强，用来进行各种方便高效的操作，过程就像工人在流水线上加工一样。Stream 的操作分为三步：创建流、中间操作、终止操作，只有添加了终止操作其它的步骤才会执行。单个元素执行完所有操作后，再进行下一个元素。

  • 无状态：指元素的处理不受之前元素的影响。
  • 有状态：指该操作只有拿到所有元素之后才能继续操作。
  • 非短路操作：指必须处理所有元素才能得到结果。
  • 短路操作：指遇到某些符合条件的元素就可以得到最终结果。
中间操作无状态unordered、filter、map、mapToInt、mapToLong、mapToDouble、flatMap、flatMapToInt、flatMapToLong、flatMapToDouble、peek
有状态distinct、sorted、limit、skip
终止操作非短路操作forEach、forEachOrdered、toArray、reduce、collect、max、min、count
短路操作anyMatch、allMatch、noneMatch、findFirst、findAny

创建流

从数据源中获取流，例如从集合、数组、另一个流、文件。

流和迭代器类似只能迭代一次，并行流就是把内容分成多个数据块使用不同的线程分别处理每个数据块的流。

创建流作用说明
Collection 实例调用stream ()转换为一个串行流（顺序流）功能上没有差别，单线程和多线程的效率区别。
parallelStream()转换为一个并行流（坑多少用）
Arrays 静态调用

stream ( T [ ] )

stream ( int [ ] )

stream ( double [ ] )

stream ( long [ ] )

转换为一个流
Stream 静态调用of ( T... )用传入的值生成流值生成流
empty ()创建一个空的流
iterate ()依次对每个新生成的值应用函数函数生成流
generate ()根据函数生成值
Files 静态调用lines ()转换为一个流每个元素是文件的其中一行
//Collection
List list = new ArrayList();
list.stream();
list.parallelStream();

Set set = new HashSet();
set.stream();

Map map = new HashMap();
map.keySet().stream();
map.values().stream();
map.entrySet().stream();

//Arrays
int[] aa = {1,2,3,4};
Arrays.stream(aa,1,3).forEach(System.out::println);    //打印：2,3

//Stream
Stream<String> stream4 = Stream.of("aaa","bbb","ccc");    //也可以传入数组，可变参数就是数组
Stream<int[]> stream5 = Stream.of(aa);    //但是不能传入基本数据类型的数组，整个数组会被看作成一个元素，而不是对每个元素操作
Stream<Integer> stream6 = Stream.iterate(0, n -> n + 2);    //首元素为0，之后依次+2
Stream<Object> stream7 = Stream.generate(MAth::random);    //元素为0到1的随机双精度
Stream<Integer> stream8 = Stream.generate(() -> 1);    //元素全为1

//Files
String<String> stream9 = Files.lines(Paths.get("data.txt"));

合并流

静态方法，将两个流合并成一个流，合并之后不能再操作之前的流。 

Stream<String> stream1 = Stream.of("张三");
Stream<String> stream2 = Stream.of("李四");
Stream<String> stream3 = Stream.concat(stream1, stream2);   //合并之后不能再操作stream1，stream2
stream3.forEach(System.out::println);   //打印：张三，李四

中间操作符 

在执行处理后会返回一个新的流，供后续操作。

中间操作符作用说明
filter (Predicate predicate)过滤通过设置的条件过滤出元素
distint ()去重通过equals()去除重复元素
limit (long maxSize)限流选取前几个元素，限制最大数量
skip (long n)跳过去除前几个元素，数量不足返回空流
map (Function mapper)转换类型转换，接收的函数作用于每个元素上，返回的是流中流
flatmap (Function mapper)拍平将每个元素映射为一个流(流中流)，再将每个流连接成一个流
peek (Consumer action)挑出

sorted

sorted (Comparator comparator)

自然排序

比较器排序

ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌", "赵敏", "张三丰", "周芷若", "张峰");

//过滤 filter()
list1.stream()
        .filter(s -> s.startsWith("张")) //拿到以"张"开头的元素
        .filter(s -> s.length() == 3) //拿到长度为3的元素
        .forEach(System.out::println);  //遍历打印：张无忌、张三丰
//限流 limit()
list1.stream().limit(3).forEach(System.out::println);    //遍历打印：张无忌、赵敏、张三丰
//跳过 skip()
list1.stream().skip(3).forEach(System.out::println);     //遍历打印：周芷若、张峰
//转换 map()
List<String> list2 = Arrays.asList("1", "2", "3");
Stream<Integer> stream = list2.stream().map(Integer::parseInt); //泛型String变为Integer
//排序 sorted()
Stream.of(21, 45, 3, 64, 234, 1).sorted().forEach(System.out::println); //自然排序：1,3,21,45,64,234
Stream.of(21, 45, 3, 64, 234, 1).sorted((o1, o2) -> o2 - o1).forEach(System.out::println);   //比较器排序，上面的降序打印
//去重 distint()
Stream.of(1, 3, 2, 2, 1, 3).distinct().forEach(System.out::println);    //遍历打印：1,3,2

终止操作符

Stream必须使用终止操作符，否则整个流是不会流动起来的，即操作不会执行。

操作类型终止操作符作用
收集collect ()将所有元素收集起来，Collectors提供了非常多的收集器
匹配allMatch (Predicate predicate)每个元素都符合判断返回true，否则false
noneMatch (Predicate predicate)每个元素都不符合判断返回true，否则false
anyMatch (Predicate predicate)只要有一个元素符合判断返回true，否则false
查找findFrist ()返回第一个元素
findAny ()

使用 stream()，返回第一个元素

使用 parallelStream()，返回随机一个元素

统计count ()返回元素的个数
最值max (Comparator comparator)返回最大值
min (Comparator comparator)返回最小值
规约reduce ()将整个流的值规约为一个值，count、min、max底层使用的这个
遍历forEach ()对最终数据进行消费了
forEachOrdered ()
数组toArray ()

将流的元素转换成数组 

List<String> list = Arrays.asList("A", "B", "C", "D");
//遍历 fotEach()
list.stream().forEach(System.out::println); //遍历打印：A,B,C,D
//统计 count()
System.out.println(list.stream().count());  //打印：4
//匹配 match()
boolean b = Stream.of(1, 4, 23, 54, 12, 6, 33)
//                .allMatch(num -> num > 3) //是否全部匹配
//                .anyMatch(num -> num > 3) //是否任一匹配
        .noneMatch(num -> num > 3); //是否都不匹配
//查找 findFirst()
Optional<Integer> first = Stream.of(33, 11, 22, 5).findFirst();
int num = first.get(); //33
//最值 max()、min()
Optional<Integer> max = Stream.of(33, 11, 22, 5).max(Integer::compareTo);   //自然排序
Optional<Integer> min = Stream.of(33, 11, 22, 5).min((o1, o2) -> o2 - o1);   //比较器排序，倒序
System.out.println(max.get());  //33
System.out.println(min.get());  //33
//规约 reduce()
//参数一：默认值   参数二：数据处理方式
//第一次：将默认值参数一赋值给a，流中第一个元素赋值给b，进行数据处理
//第二次：将处理结果赋值给a，流中第二个元素赋值给b，进行数据处理
//以此类推...
Integer reduce = Stream.of(1, 2, 3, 4).reduce(0, (a, b) -> {
    System.out.println("a=" + a + ",b=" + b);
    return a + b;
});
System.out.println(reduce); //10
//转为数组 toArray()
Object[] objects = Stream.of("哈哈", "呵呵").toArray(); //转为Object数组不方便
String[] strings = Stream.of("哈哈", "呵呵").toArray(String[]::new);    //转为String类型数组

collect() 收集数据 

传入的参数说明

Collectors.toList ()

Collectors.toSet ()

Collectors.toCollection ()

把流中所有元素收集到一个 List, Set 或 Collection 中
Collectors.counting ()元素数量

Collectors.maxBy ()

最大值
Collectors.minBy ()最小值

Collectors.summingInt ()

Collectors.summingDouble ()

Collectors.summingLong ()

总和

Collectors.averagingInt ()

Collectors.averagingDouble ()

Collectors.averagingLong ()

平均值

Collectors.groupingBy ()

Collection.partitioningBy ()

分组

分区

根据元素属性进行分组（可分为多组）

根据条件判断进行分区（true false只有两个）

Collection.joining ()拼接
Stream<Integer> stream = Stream.of(1, 4, 2, 3, 4);
//转为List
List<Integer> list = stream.collect(Collectors.toList());
//转为HashSet，自动去重
HashSet<Integer> hashSet = stream.collect(Collectors.toCollection(HashSet::new));

List<Person> list = Arrays.asList(new Person("张三", 18), new Person("李四", 20), new Person("王五", 22), new Person("赵六", 31));
//元素个数 Collectors.counting()
Long number = list.stream().collect(Collectors.counting());
System.out.println("y元素个数是：" + number);  //元素个数是：4
//最大值 Collectors.maxBy()
Optional<Person> max = list.stream().collect(Collectors.maxBy((o1, o2) -> o1.age - o2.age));
System.out.println("最大年龄是：" + max.get());    //最大年龄是：Person{name='赵六', age=31}
//最小值 Collectors.minBy()
Optional<Person> min = list.stream().collect(Collectors.minBy((o1, o2) -> o1.age - o2.age));
System.out.println("最小年龄是：" + min.get());    //最小年龄是：Person{name='张三', age=18}
//总和 Collectors.summingInt()
Integer totalAge = list.stream().collect(Collectors.summingInt(value -> value.age));
System.out.println("年龄总和是：" + totalAge);    //年龄总和是：91
//平均值 Collectors.averagingInt()
Double averageAge = list.stream().collect(Collectors.averagingInt(value -> value.age));
System.out.println("年龄平均是：" + averageAge);  //年龄平均是：22.75

//分组 Collectors.groupingBy()
List<Person> list2 = Arrays.asList(new Person("张三", 18), new Person("张三", 31), new Person("李四", 19), new Person("李四", 33));
//名字相同为一组
Map<String, List<Person>> nameGroup = list2.stream().collect(Collectors.groupingBy(Person::getName));
/*
    姓名为【李四】的人员有：李四19, 李四33
    姓名为【张三】的人员有：张三18，张三31
 */
nameGroup.forEach((name, people) -> System.out.println("姓名为【" + name + "】的人员有：" + people));
//年龄<20组名青年，年龄>20组名“中年”
Map<String, List<Person>> ageGroup = list2.stream().collect(Collectors.groupingBy(person -> {
    if (person.getAge() < 20)
        return "青年";
    else
        return "中年";
}));
/*
    年龄段为【青年】的人员有：张三18, 李四19
    年龄段为【中年】的人员有：张三31, 李四33
 */
ageGroup.forEach((age, people) -> System.out.println("年龄段为【" + age + "】的人员有：" + people));
//多级分组
/*
    姓名为【李四】的人员里面：
        年龄段为【青年】的人员有：李四19
        年龄段为【中年】的人员有：李四33
    姓名为【张三】的人员里面：
        年龄段为【青年】的人员有：张三18
        年龄段为【中年】的人员有：张三31
 */
Map<String, Map<String, List<Person>>> map = list2.stream().collect(Collectors.groupingBy(Person::getName, Collectors.groupingBy(person -> {    //第二个参数可以是任意Collectors的收集器
    if (person.getAge() < 20)
        return "青年";
    else
        return "中年";
})));
map.forEach((key, value) -> {
    System.out.println("姓名为【" + key + "】的人员里面：");
    value.forEach((k, v) -> {
        System.out.println("\t年龄段为【" + k + "】的人员有：" + v);
    });
});
//分组 partitionBy()，重载方法也支持多级分组
Map<Boolean, List<Person>> map2 = list2.stream().collect(Collectors.partitioningBy(person -> person.age > 20));
/*
    分组为【false】里面的元素有：张三18, 李四19
    分组为【true】里面的元素有：张三31,李四33
 */
map2.forEach((aBoolean, people) -> System.out.println("分组为【" + aBoolean + "】里面的元素有：" + people));

//拼接 joining()
//无参方法：直接拼接
//一个参数方法：连词符
//三个参数方法：连词符，前缀，后缀
System.out.println("--------------------------");
String join1 = list.stream().map(person -> person.getName()).collect(Collectors.joining()); //张三李四王五赵六
String join2 = list.stream().map(person -> person.getName()).collect(Collectors.joining("-"));  //张三-李四-王五-赵六
String join3 = list.stream().map(person -> person.getName()).collect(Collectors.joining("-","前缀","后缀"));    //前缀张三-李四-王五-赵六后缀

数值流

计算元素的时候存在装箱拆箱成本，因此引入数值流来减少内存开销。

方法说明
mapToInt (T -> int)
mapToDouble (T -> double)
mapToLong (T -> long)		将Stream转换为数值流

IntStream
DoubleStream

LongStream

boxed ()将数值流转换为Stream

rangeClosed (int, int)

rangeClosed (long, long)

闭区间，值包括首位

(1,100) 值为1...100

range (int, int)

range (long, long)

左闭右开区间，值不包括最后一位

(1,100] 值为1...99

IntStream intStream = Stream.of(1, 2, 3, 4).mapToInt(num -> num.intValue());//可以使用Integer::intValue
Stream<Integer> stream = intStream.boxed();
//1到100累加的总和
int sum = IntStream.rangeClosed(1, 100).sum();
System.out.println(sum);    //5050

并行流 （坑多少用）

        并行处理会将一个大任务切分成多个小任务，充分利用多核CPU的优势，底层实现原理是Fork/Join。但不一定效率就是最高的，例如存在装箱问题，使用的时候也无法保证元素的顺序性。

public static void main(String[] args) {
    //创建并行流
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> parallelStream1 = list.parallelStream();//直接获取并行流
    Stream<Integer> parallelStream2 = list.stream().parallel();//将串行流转换为并行流

    //查看线程名称
    parallelStream1.filter(integer -> {
        System.out.println(Thread.currentThread());
        return integer > 10;
    }).count();

    //效率比较
    System.out.println("for循环，所耗时间为：" + getTime(num -> {    //所耗时间为：1066
        int sum = 0;
        for (int x = 0; x < num; x++) {
            sum += x;
        }
    }));
    System.out.println("串行流，所耗时间为：" +getTime(num ->{    //所耗时间为：263
        LongStream.rangeClosed(0,num).reduce(0,Long::sum);
    }));
    System.out.println("并行流，所耗时间为：" +getTime(num ->{    //所耗时间为：140
        LongStream.rangeClosed(0,num).parallel().reduce(0,Long::sum);
    }));
}

//分别用for循环、串行流、并行流计算5亿相加的和所花费的时间
public static String getTime(Consumer<Long> consumer) {
    long start = System.currentTimeMillis();
    consumer.accept(5_0000_0000L);
    long end = System.currentTimeMillis();
    return "" + (end - start);
}

线程安全解决方法：

        ①使用同步锁

        ②使用线程安全的集合

        ③使用 boxed() 转为串行流 Stream 再操作

//线程不安全
List<Integer> list1 = new ArrayList<>();
IntStream.rangeClosed(1, 1000).parallel().forEach(list1::add);
System.out.println("线程不安全："+list1.size());    //不为1000
//方式一：同步代码块
List<Integer> list2 = new ArrayList<>();
Object obj = new Object();
IntStream.rangeClosed(1, 1000).parallel().forEach(value -> {
    synchronized (obj) {
        list2.add(value);
    }
});
System.out.println("方式一："+list2.size());    //为1000
//方式二：使用线程安全的集合
Vector<Integer> vector = new Vector<>();    //使用线程同步的集合Vector
List<Integer> synchronizedList = Collections.synchronizedList(new ArrayList<>());   //使用Collections方法返回一个线程安全的List
IntStream.rangeClosed(1, 1000).parallel().forEach(vector::add);
IntStream.rangeClosed(1, 1000).parallel().forEach(synchronizedList::add);
System.out.println("方式二 Vctor："+vector.size());    //为1000
System.out.println("方式二：Collections："+synchronizedList.size());    //为1000
Jomurphys
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8系列--Java Stream进阶篇（流的操作）
m0_59092234的博客
08-01 241
在Java8StreamAPI中，流的操作实际上相当于对数据进行一系列的”筛选”操作，而”筛选”的标准实际上是一个个具体的”方法”，在Java8Stream中，是通过将这些筛选方法作为Stream流的一系列内部迭代的方法参数来实现的。流支持limit(n)方法，该方法会返回一个给定长度的流，该方法的参数是一个整数n，该参数即为限定的长度。这里，filter()方法是Stream的内部迭代方法，而car.getPrice()>300是该filter()方法的一个内部参数。以下面的例子展开讲解。...
java8-Stream API终端操作.pdf
07-12
Java Stream 管道流数据处理操作可以分为三个阶段：第一阶段是将集合、数组或文本文件转换为 Java Stream 管道流，第二阶段是对管道流式数据处理操作，第三阶段是管道流结果处理操作，本文将主要介绍第三阶段的操作...
JAVA8的新特性之Stream
愚者的博客
06-22 370
JAVA8的新特性之Stream 1、概述： 在jdk1.8中，提供了一个Stream，可以对数据进行过滤 2、好处： 比不断自定义循环，要简单很多 Stream类型数据的获取 1、Collection 的获取 调用stream()方法，返回Stream类型的实现类对象 2、Map的获取，不能直接获取Stream类型 （1）keySet().stream(); (2)entrySet().stream(); 3、数组的获取 Stream中的of方法，Stream.of(数组) package com.uji
Stream 流
bm1998
10-21 347
文章目录1. 体验 Stream 流2. Stream 流的思想3. Stream 流的生成方式4. Stream 流的常见中间操作方法5. Stream 流终结操作方法6. Stream 流综合练习7. Stream 流的收集操作 1. 体验 Stream 流 需求： 创建一个集合，存储多个字符串元素 把集合中所有以"张"开头的元素存储到一个新的集合 把"张"开头的集合中的长度为 3 的元素存储到一个新的集合 遍历上一步得到的集合 实现： public class StreamDemo { p
Java------Stream流式编程常用API【.stream，filter()，map()】（三）
cz_chen_zhuo的博客
08-01 899
基于数组生成流对象。既可以通过Stream.of（），也可以直接调用.stream方法。test方法产生一个boolean结果，为true则为新流的元素保留，为false则舍弃该元素。map是通过对keySet，以及Values集合生成流对象。list里放list的结构，流操作时，需要进行两次流转换。针对数组、List、Map、Set生成流对象。也可以再进行一次filter过滤方法。基于collection对象生成流。可以使用或、与进行多条件判断。分为基础API和高阶API。示例2，返回Map形式的流。..
Java Stream（6）
热门推荐
engchina的专栏
04-21 1万+
【中间操作】 中间操作的主要方法 方法名 说明 Stream filter(Predicat predicate) 返回一个符合指定条件的Stream。 Stream distinct() 返回一个不包括重复元素的Stream。 Stream limit(long maxSize) 返回maxSize的长度的Stream。
Java之Stream流
nuist_NJUPT的博客
08-07 2462
本文主要介绍了Stream流，包括集合和数组的Stream流创建方式，List和Set集合直接使用stream()方法创建,Map集合间接使用stream()方法创建，而数组使用Stream流的静态方法of()创建，介绍了Stream流的中间操作，包括过滤filter(),限制limit()和跳过skip()，拼接concat)(),去重distinct(),排序sorted()等，最后介绍了终结草族forEach()和count()，最后给出Stream流的收集操作和综合练习。......
Java8- Stream API的用法.pdf
07-05
Java 8 中引入的 Stream API 是 Java 开发的一个里程碑式的功能特性，极大的方便了开发人员处理集合类数据的效率。Stream API 使得开发人员可以使用更简洁、易用、快捷的方式来处理集合类数据，而不是传统的 for ...
Java8 Stream API 详细使用方法与操作技巧指南
08-19
Java8 Stream API 详细使用方法与操作技巧指南 Java 8 引入了 Stream API，这是一个重要的特性，允许开发者以一种声明式的方式对数据进行处理。Stream 翻译过来是“流”，它可以看做是一个可操作的数据集序列，具有...
Java 8 Stream Api 中的 map和 flatMap 操作方法
08-25
Java 8 Stream Api 中的 map 和 flatMap 操作方法 ...map 和 flatMap 操作是 Java 8 Stream Api 中两个非常有用的操作方法，掌握这两个操作方法可以帮助开发者更方便地解决一些数据流的操作问题。
Java8中级篇--接口-异常与集合
06-09
Java 8对集合框架进行了许多增强，例如引入了流（Stream）API，它提供了函数式编程的风格，使数据处理更加简洁高效。 泛型是Java 5引入的一个重要特性，它允许在类、接口和方法中使用类型参数，从而增强了类型安全...
Java8新特性之Stream流（六）
JackieBlog
04-16 4452
1. Stream流介绍 2. Stream的创建方式 3. Stream的中间操作 4. Stream的终止操作 5. Stream的并行流 6. Stream的注意事项 7. 相关链接
Java从Map中模糊匹配key值
zlfjavahome的专栏
04-15 5188
map = map.entrySet().stream() .filter((e) -> checkKey(e.getKey(),filters)) .collect(Collectors.toMap( (e) -> (String) e.getKey(), (e) -> e.getValue() .
JavaSE进阶09：Stream流、File类
XXXZhy丶Blog
04-15 659
系列文章目录 JavaSE进阶01：继承、修饰符 JavaSE进阶02：多态、抽象类、接口 JavaSE进阶03：内部类、Lambda表达式 JavaSE进阶04：API中常用工具类 JavaSE进阶05：包装类、递归、数组的高级操作、异常 JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树 JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数
Stream流
weixin_44079370的博客
12-26 604
1、使用Stream流遍历集合 public static void main(String[] args) { /* 创建一个集合，对集合中的任务姓名进行筛选，只输出名字姓张且只有三位的名字 */ ArrayList<String> list = new ArrayList<>(); list.add("张三丰"); list.add("张无忌"); l
13.Stream流
勇敢牛牛
08-19 343
函数式接口不光有supplier接口、consumer接口，还有以下： Predicate 表示条件判断 可以用Java.Util.functiion.Predicate&lt;T&gt;接口 抽象方法：                    Test： 测试：参数代表需要对什么数据进行检测，返回值是boolean值。 默认方法： And   并且：两者条件必须都满足，“并且”--...
Java基础：Stream流常用方法
wangshiqi666的博客
04-18 1846
java中stream流
Java8 stream处理List，Map总结
y19910825的博客
11-29 6501
Stream（流）是一个来自数据源的元素队列并支持聚合操作
文件链接
qq_43904298的博客
10-14 259
文件链接 链接方式 软链接：类似于Windows的快捷方式 硬链接：为inode分配多个文件名，通过文件名找到inode 硬链接特点 不论是修改源文件，还是修改硬链接文件，另一个文件中的数据都会发生改变 不论是删除源文件还是删除硬链接文件，只要还有一个文件存在，这个文件都可以被访问 硬链接不会建立新的inode信息，也不会更改inode数 硬链接不能跨文件系统建立，因为在不同文件系统中，inode号是重新计算的 硬链接不能链接目录 软链接特点 不论是修改源文件，还是修改硬链接文件，另一个文件中的数据都会
Java Stream使用（学习资料）
最新发布
06-17
Java Stream是Java 8引入的一个功能特性，它是一个数据流经的管道，可以方便开发人员处理集合类数据的操作。相比传统的for循环，Java Stream提供了一种更加简洁、易用和快捷的方式来对集合进行操作。 Java Stream的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值