java Stream使用

已于 2023-02-04 21:55:18 修改
阅读量1.2k 收藏 3
点赞数
分类专栏： JAVA 文章标签： java
于 2021-01-22 17:21:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/X_W_T/article/details/112969952
版权

stream的使用


数据集合 

ArrayList<Person> list = new ArrayList<>(10);
list.add(new Person().setId(0).setAge(10).setName("a"));
list.add(new Person().setId(1).setAge(11).setName("b"));
list.add(new Person().setId(2).setAge(12).setName("c"));
list.add(new Person().setId(3).setAge(13).setName("d"));
list.add(new Person().setId(4).setAge(14).setName("e"));
list.add(new Person().setId(5).setAge(15).setName("f"));
list.add(new Person().setId(6).setAge(16).setName("g"));
list.add(new Person().setId(7).setAge(17).setName("h"));
list.add(new Person().setId(8).setAge(18).setName("i"));
list.add(new Person().setId(9).setAge(19).setName("j"));

stream特点

  • Stream不调用终止方法，中间的操作不会执行。

stream和parallelStream的区别

  • stream 是顺序流，由主线程按顺序对流执行操作。

  • parallelStream 是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。

示例代码：

list.parallelStream().forEach(System.out::println);
System.out.println(("----------"));
list.stream().forEach(System.out::println);

运行结果：

Person(id=6, age=16, name=g)
Person(id=5, age=15, name=f)
Person(id=8, age=18, name=i)
Person(id=2, age=12, name=c)
Person(id=1, age=11, name=b)
Person(id=7, age=17, name=h)
Person(id=4, age=14, name=e)
Person(id=3, age=13, name=d)
Person(id=9, age=19, name=j)
Person(id=0, age=10, name=a)
----------
Person(id=0, age=10, name=a)
Person(id=1, age=11, name=b)
Person(id=2, age=12, name=c)
Person(id=3, age=13, name=d)
Person(id=4, age=14, name=e)
Person(id=5, age=15, name=f)
Person(id=6, age=16, name=g)
Person(id=7, age=17, name=h)
Person(id=8, age=18, name=i)
Person(id=9, age=19, name=j)

filter 过滤（中间操作）

示例代码：

list.stream().filter(person -> person.getId() > 5).forEach(System.out::println);

运行结果：

Person(id=6, age=16, name=g)
Person(id=7, age=17, name=h)
Person(id=8, age=18, name=i)
Person(id=9, age=19, name=j)
  • 满足条件的元素通过(true)，不满足条件的元素会被丢弃(false)

forEach 对流进行遍历（终止操作）

示例代码：

list.stream().forEach(System.out::println); // 方法引用

运行结果：

Person(id=0, age=10, name=a)
Person(id=1, age=11, name=b)
Person(id=2, age=12, name=c)
Person(id=3, age=13, name=d)
Person(id=4, age=14, name=e)
Person(id=5, age=15, name=f)
Person(id=6, age=16, name=g)
Person(id=7, age=17, name=h)
Person(id=8, age=18, name=i)
Person(id=9, age=19, name=j)

示例代码：

list.stream().forEach(person -> System.out.print(person.getId()));

运行结果：

0123456789

limit 按给定长度截断流（中间操作）

示例代码：

list.stream().limit(5L).forEach(System.out::println);

运行结果：

Person(id=0, age=10, name=a)
Person(id=1, age=11, name=b)
Person(id=2, age=12, name=c)
Person(id=3, age=13, name=d)
Person(id=4, age=14, name=e)

map和flatMap将函数作用于每个元素（中间操作）

map和flatMap的区别
在这里插入图片描述
flatMap所用映射函数返回值必须为Stream，会将返回的Stream展开并集合起来重新串成一个新的Stream。

map所用映射函数可返回任意类型元素，直接将返回元素串起来形成一个新的Stream。

示例代码：

list.stream().flatMap(person -> {
    ArrayList<Person> append = new ArrayList<>(2);
    append.add(person);
    append.add(new Person().setId(person.getId() + 10));
    return append.stream();
}).forEach(System.out::println);

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

list.stream().map(person -> {
    ArrayList<Person> append = new ArrayList<>(2);
    append.add(person);
    append.add(new Person().setId(person.getId() + 10));
    return append.stream();
}).forEach(System.out::println);

运行结果：

Person(id=0, age=10, name=a)
Person(id=10, age=0, name=null)
Person(id=1, age=11, name=b)
Person(id=11, age=0, name=null)
Person(id=2, age=12, name=c)
Person(id=12, age=0, name=null)
Person(id=3, age=13, name=d)
Person(id=13, age=0, name=null)
Person(id=4, age=14, name=e)
Person(id=14, age=0, name=null)
Person(id=5, age=15, name=f)
Person(id=15, age=0, name=null)
Person(id=6, age=16, name=g)
Person(id=16, age=0, name=null)
Person(id=7, age=17, name=h)
Person(id=17, age=0, name=null)
Person(id=8, age=18, name=i)
Person(id=18, age=0, name=null)
Person(id=9, age=19, name=j)
Person(id=19, age=0, name=null)
------------------
java.util.stream.ReferencePipeline$Head@6a5fc7f7
java.util.stream.ReferencePipeline$Head@3b6eb2ec
java.util.stream.ReferencePipeline$Head@1e643faf
java.util.stream.ReferencePipeline$Head@6e8dacdf
java.util.stream.ReferencePipeline$Head@7a79be86
java.util.stream.ReferencePipeline$Head@34ce8af7
java.util.stream.ReferencePipeline$Head@b684286
java.util.stream.ReferencePipeline$Head@880ec60
java.util.stream.ReferencePipeline$Head@3f3afe78
java.util.stream.ReferencePipeline$Head@7f63425a

示例代码：

System.out.println(list.stream().map(person -> 10).collect(Collectors.toList()));
System.out.println(list.stream().map(person -> "hello").collect(Collectors.toList()));

运行结果：

[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
[hello, hello, hello, hello, hello, hello, hello, hello, hello, hello]

mapToInt 函数返回值必须为int类型
flatMapToInt 函数返回值必须为IntegerSteam类型
mapToDouble 函数返回值必须为double类型
flatMapToDouble 函数返回值必须为DobuleSteam类型
mapToLong 函数返回值必须为long类型
flatMapToLong 函数返回值必须为LongStream类型

allMatch 流中所有元素都满足条件（终止操作）

示例代码：

System.out.println(list.stream().allMatch(person -> person.getId() == 5));
System.out.println(list.stream().allMatch(person -> person.getId() != 11));

输出结果：

false
true

anyMatch 流中是否有元素满足条件（终止操作）

示例代码：

System.out.println(list.stream().anyMatch(person -> person.getAge() == 11));
System.out.println(list.stream().anyMatch(person -> person.getAge() == 1));

运行结果：

true
false

noneMatch 流中没有元素满足条件（终止操作）

示例代码：

System.out.println(list.stream().noneMatch(person -> person.getId() == 5));
System.out.println(list.stream().noneMatch(person -> person.getId() == 15));

运行结果：

false
true

count 返回流的大小（终止操作）

示例代码：

System.out.println(list.stream().count());

输出结果：

10

distinct 去除重复元素（中间操作）

示例代码：

List<Integer> integerList = Arrays.asList(1, 2, 3, 3, 4, 4, 5, 6);
System.out.println(integerList.stream().distinct().collect(Collectors.toList()));

运行结果：

[1, 2, 3, 4, 5, 6]

findFirst 返回流的第一个元素（终止操作）

示例代码：

Optional<Person> optionalPerson = list.stream().findFirst();
optionalPerson.ifPresent(System.out::println);

输出结果：

Person(id=0, age=10, name=a)

findAny 返回流中任意一个元素（终止操作）

findAny操作，返回的元素是不确定的，对于同一个列表多次调用findAny()有可能会返回不同的值。使用findAny()是为了更高效的性能。如果是数据较少，串行地情况下，一般会返回第一个结果，如果是并行的情况，那就不能确保是第一个。

示例代码：

Optional<Person> optionalPerson = list.parallelStream().findAny();
optionalPerson.ifPresent(System.out::println);

运行结果：

Person(id=6, age=16, name=g)

concat 拼接两个流

示例代码：

ArrayList<Person> list2 = new ArrayList<>(2);
list2.add(new Person().setId(10).setAge(20).setName("k"));
list2.add(new Person().setId(11).setAge(21).setName("l"));
Stream<Person> stream = Stream.concat(list.stream(), list2.stream());
stream.forEach(System.out::println);

运行结果：

Person(id=0, age=10, name=a)
Person(id=1, age=11, name=b)
Person(id=2, age=12, name=c)
Person(id=3, age=13, name=d)
Person(id=4, age=14, name=e)
Person(id=5, age=15, name=f)
Person(id=6, age=16, name=g)
Person(id=7, age=17, name=h)
Person(id=8, age=18, name=i)
Person(id=9, age=19, name=j)
Person(id=10, age=20, name=k)
Person(id=11, age=21, name=l)

generate 根据提供的方法，持续生成流

示例代码：

// 如果没有limit，控制台将持续打印生成的随机数。
Stream.generate(Math::random).limit(5).forEach(System.out::println);

Stream<Double> generateB = Stream.generate(()-> Math.random()).limit(5).forEach(System.out::println);

Stream<Double> generateA = Stream.generate(new Supplier<Double>() {
    @Override
    public Double get() {
        return Math.random();
    }
}).limit(5).forEach(System.out::println);
// 三者等价，Supplier为函数接口

运行结果：

0.5137198806722759
0.6204101302224982
0.2502610330633914
0.32596750750752745
0.4628503400128364

iterate 指定种子进行迭代

示例代码：

Stream.iterate(1, item -> item + 1).limit(10).forEach(item -> System.out.print(item + "\t"));

运行结果：

1	2	3	4	5	6	7	8	9	10

示例代码：

Stream.iterate('a', item -> (char)(item + 1)).limit(10).forEach(item -> System.out.print(item + "\t"));

运行结果：

a	b	c	d	e	f	g	h	i	j

max和min根据提供的比较函数返回此流的最大|小元素

示例代码：

Optional<Person> optionalPerson = list.stream().max((t1, t2) -> {
    return Integer.compare(t1.getAge(), t2.getAge());
});
optionalPerson.ifPresent(System.out::println);

// 等价于
Optional<Person> optionalPerson = list.stream().max(Comparator.comparingInt(Person::getAge));
// 比较结果返回值
// 返回负整数，零或正整数，因为第一个参数小于，等于或大于第二个参数
(t1 < t2) ? -1 : ((t1 == t2) ? 0 : 1);

运行结果：

Person(id=9, age=19, name=j)

示例代码：

Optional<Person> optionalPerson = list.stream().min(Comparator.comparingInt(Person::getAge));
optionalPerson.ifPresent(System.out::println);

运行结果：

Person(id=0, age=10, name=a)

peek 将流中元素作用于函数（中间操作）

示例代码：

list.stream().peek(person -> person.setId(0)).forEach(System.out::println);

运行结果：

Person(id=0, age=10, name=a)
Person(id=0, age=11, name=b)
Person(id=0, age=12, name=c)
Person(id=0, age=13, name=d)
Person(id=0, age=14, name=e)
Person(id=0, age=15, name=f)
Person(id=0, age=16, name=g)
Person(id=0, age=17, name=h)
Person(id=0, age=18, name=i)
Person(id=0, age=19, name=j)

skip 跳过元素（中间操作）

示例代码：

list.stream().skip(5).forEach(System.out::println);

运行结果：

Person(id=5, age=15, name=f)
Person(id=6, age=16, name=g)
Person(id=7, age=17, name=h)
Person(id=8, age=18, name=i)
Person(id=9, age=19, name=j)

reduce 将流中元素结合起来得到一个值（终止操作）

方法一：
示例代码：

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
stream.reduce((item1, item2) -> {
    System.out.println("item1:" + item1 + "  item2:" + item2);
    return item1 + item2;
}).ifPresent(System.out::print);
// 返回值为optional类型

运行结果：

item1:1  item2:2
item1:3  item2:3
item1:6  item2:4
item1:10  item2:5
item1:15  item2:6
item1:21  item2:7
item1:28  item2:8
item1:36  item2:9
45

方法二：
示例代码：

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
System.out.println(stream.reduce(10, (item1, item2) -> {
    System.out.println("item1:" + item1 + "  item2:" + item2);
    return item1 + item2;
}));
// 第一个参数必须于stream中元素的类型相同。返回值为相同元素类型

运行结果：

item1:10  item2:1
item1:11  item2:2
item1:13  item2:3
item1:16  item2:4
item1:20  item2:5
item1:25  item2:6
item1:31  item2:7
item1:38  item2:8
item1:46  item2:9
55

方法三：
示例代码：

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
ArrayList<Integer> integers = new ArrayList<>();
System.out.println(stream.reduce(integers, (array, item) -> {
    System.out.println("array:" + array + "  item:" + item);
    array.add(item);
    return array;
}, (item1, item2) -> null));
// 返回值类型可以自定义

运行结果：

array:[]  item:1
array:[1]  item:2
array:[1, 2]  item:3
array:[1, 2, 3]  item:4
array:[1, 2, 3, 4]  item:5
array:[1, 2, 3, 4, 5]  item:6
array:[1, 2, 3, 4, 5, 6]  item:7
array:[1, 2, 3, 4, 5, 6, 7]  item:8
array:[1, 2, 3, 4, 5, 6, 7, 8]  item:9
[1, 2, 3, 4, 5, 6, 7, 8, 9]

第三个参数定义的规则并没有执行。这是因为reduce的第三个参数是在使用parallelStream的reduce操作时，合并各个流结果的，本例中使用的是stream，所以第三个参数是不起作用的。

toArray将流中元素封装成数组（终止操作）

示例代码：

System.out.println(list.stream().toArray());
for (Object o : list.stream().toArray()) {
    System.out.println(o);
}
System.out.println(list.stream().toArray(Person[]::new));
for (Person person : list.stream().toArray(Person[]::new)) {
    System.out.println(person);
}

运行结果：

[Ljava.lang.Object;@880ec60
Person(id=0, age=10, name=a)
Person(id=1, age=11, name=b)
Person(id=2, age=12, name=c)
Person(id=3, age=13, name=d)
Person(id=4, age=14, name=e)
Person(id=5, age=15, name=f)
Person(id=6, age=16, name=g)
Person(id=7, age=17, name=h)
Person(id=8, age=18, name=i)
Person(id=9, age=19, name=j)
[Lstream.Person;@36d64342
Person(id=0, age=10, name=a)
Person(id=1, age=11, name=b)
Person(id=2, age=12, name=c)
Person(id=3, age=13, name=d)
Person(id=4, age=14, name=e)
Person(id=5, age=15, name=f)
Person(id=6, age=16, name=g)
Person(id=7, age=17, name=h)
Person(id=8, age=18, name=i)
Person(id=9, age=19, name=j)

sorted 对流中元素进行排序（中间操作）

示例代码：

Stream<Integer> stream1 = Stream.generate(() -> new Random().nextInt(10)).limit(10);
Stream<Integer> stream2 = stream1.peek(item -> System.out.print(item + "\t"));
stream2.sorted().forEach(item -> System.out.print(item + "\t"));
// stream2.sorted(Integer::compareTo).forEach(item -> System.out.print(item + "\t"));

运行结果：

4	3	8	9	6	0	7	8	9	1 	0	1	3	4	6	7	8	8	9	9

empty返回一个空的流

Stream<Person> stream = Stream.empty();

of 返回其元素是指定值的顺序排序流

Stream<Integer> stream1 = Stream.of(1, 2, 3);
Stream<Integer> stream2 = Stream.of(1);

builder 返回stream构造器

// 创建一个流构造器
Stream.Builder<Integer> sb = Stream.builder();
sb.accept(10);
sb.add(11);
// 构造流
Stream<Integer> stream1 = sb.build();
stream1.forEach(System.out::println);
  • 流构造之后就不能使用其accept和add方法，否则会报错。
蔚_wei
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8中利用stream对map集合进行过滤的方法
阿杰同学的博客
07-16 5308
Map<String,Object> ddw=new HashMap<>(); ddw.put("height","150"); ddw.put("weight","510"); Map<String,Object> hl=new HashMap<>(); hl.put("height","160"); hl.put(" height","610"); Map<String,Object> gy=n.
java Stream
sun134911的博客
07-21 321
1.什么是 Stream？ Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。 元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。 Stream（流）是一个来自数据源的元素队列并支持聚合操作 元素是特定类型的
jstream：Go的流JSON解析器
02-03
jstream是Go的流式JSON解析器和值提取库。 与大多数JSON解析器不同， jstream具有文档位置和深度感知功能-能够提取指定深度的值，从而消除了分配包含数组或对象的开销； 例如： 使用以下示例文档： 我们可以选择仅提取并操作顶级数组中的对象： f , _ := os . Open ( "input.json" ) decoder := jstream . NewDecoder ( f , 1 ) // extract JSON values at a depth level of 1 for mv := range decoder . Stream () { fmt
Java Map 通过 key 或者 value 过滤
最新发布
2401_84690353的博客
05-23 906
关于面试刷题也是有方法可言的，建议最好是按照专题来进行，然后由基础到高级，由浅入深来，效果会更好。Java基础部分算法与编程!imageMogr必看视频！获取2024年最新Java开发全套学习资料 备注Java数据库部分流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。
stream().map
weixin_42612405的博客
02-13 3474
stream().map 是 Java 8 中 Stream API 的一个方法。它接受一个函数作为参数，该函数会应用到 Stream 中的每个元素，并将其映射为一个新元素。这样可以对 Stream 中的元素进行转换，从而得到一个新的 Stream。 例如，下面的代码片段使用 stream().map 将 Stream 中的整数元素映射为其平方： List<Integer> numbe...
Java8的stream().map()用法
C_0010的博客
05-24 4万+
Java8，使用stream流处理map
Java8 - Streams map()
小工匠
12-31 3万+
是Stream最常用的一个转换方法，它把一个Stream转换为另一个Streammap()方法用于将一个Stream的每个元素映射成另一个元素并转换成一个新的Stream；可以将一种元素类型转换成另一种元素类型。/****map()方法接收的对象是Function接口对象，它定义了一个apply()方法，负责把一个T类型转换成R类型。其中，Function的定义为/***// 将T类型转换为R: . . . . . . . . . . . . }
stream().map()方法详解
热门推荐
qq_41135605的博客
11-04 20万+
使用Stream流时发现其中的map方法使用不好容易理解，以一个小案例详细探讨Stream中map的使用。 案例涉及知识点： 1、Stream中of方法传入可变参数 2、Stream中map元素类型转化方法 3、Function匿名接口，自定义类匿名对象的使用 4、Lambda表达式 为了便于理解，首先借鉴其他博客中的说法， stream()优点 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。 为函数式编程而生。对strea
Java Stream
weixin_51360664的博客
08-21 1688
stream详解
Java Stream 使用详解
01-20
Stream是 Java 8新增加的类，用来补充集合类。 　Stream代表数据流，流中的数据元素的数量可能是有限的，也可能是无限的。 　Stream和其它集合类的区别在于：其它集合类主要关注与有限数量的数据的访问和有效管理...
Java Stream使用（学习资料）
06-17
Java Stream 使用指南 Java Stream 是 Java 8 中引入的函数式编程接口，它极大的方便了开发人员处理集合类数据的效率。本文将详细介绍 Java Stream 的基本概念、使用方法和应用场景。 一、什么是 Java Stream API...
java stream
12-02
java stream doc.
java Stream 流使用
04-15
- 使用 `java.util.Arrays.stream(T[] array)` 从数组创建。 - 调用 Stream 的静态方法 `of()`, `iterate()`, `generate()` 创建。 举例来说，我们可以通过以下方式使用Stream： ```java List<Person> personList =...
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
1.Stream流及常用API
苏秋远的博客
06-23 1066
stream流的介绍及常见用法
stream().filter()的用法
点点滴滴
09-08 13万+
stream.filter一般适用于list集合,主要作用就是模拟sql查询，从集合中查询想要的数据。filter里面的参数user是指集合里面的每一项 public class StreamTest{ public static void main(String[] args){ List<User> list = new ArrayList<>(); //定义三个用户对象 User user1 = new User();
java8: stream().map(),filter(),Collectors.toMap
wozaichengduha的博客
03-27 1410
java8: stream().map(),filter(),Collectors.toMap
java8 ：stream().map()的相关用法
weixin_44211388的博客
03-27 8822
java8新特性、Stream流，Map()
JAVA stream使用详解
06-08
Java Stream 是 Java 8 中新增的一个 API，用于处理集合数据。它提供了一种更加简洁、高效的方式来操作集合，可以让代码更加简洁、易读、易维护。下面是 Java Stream 的基本使用方法： 1. 创建流 Java Stream 可以从多种数据源中创建，比如集合、数组、文件等。例如，从集合创建一个 Stream 可以使用以下代码： ```java List<String> list = new ArrayList<>(); Stream<String> stream = list.stream(); ``` 2. 中间操作 中间操作是指对 Stream 进行操作，返回一个新的 Stream。常见的中间操作包括：filter、map、sorted、distinct 等。例如，下面的代码使用 filter 操作过滤出长度大于 5 的字符串： ```java List<String> list = Arrays.asList("apple", "banana", "orange", "watermelon"); Stream<String> stream = list.stream().filter(s -> s.length() > 5); ``` 3. 终止操作 终止操作是指对 Stream 进行最终的操作，返回一个非 Stream 的结果。常见的终止操作包括：forEach、reduce、collect、count 等。例如，下面的代码使用 forEach 操作输出过滤后的字符串： ```java List<String> list = Arrays.asList("apple", "banana", "orange", "watermelon"); list.stream().filter(s -> s.length() > 5).forEach(System.out::println); ``` 4. 短路操作 短路操作是指对 Stream 进行操作时，只要满足一定条件就可以停止操作，不必对整个流进行操作。常见的短路操作包括：findFirst、findAny、allMatch、anyMatch、noneMatch 等。例如，下面的代码使用 findAny 操作找到第一个长度大于 5 的字符串： ```java List<String> list = Arrays.asList("apple", "banana", "orange", "watermelon"); Optional<String> result = list.stream().filter(s -> s.length() > 5).findAny(); ``` 以上就是 Java Stream 的基本使用方法，需要注意的是，Stream 是一次性的，一旦进行了终止操作，就不能再对该 Stream 进行操作。同时，Stream 也是惰性求值的，只有在终止操作时才会进行真正的计算。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值