JAVA进阶 —— Stream流

已于 2023-03-15 08:52:12 修改
阅读量6.3k 收藏 48
点赞数 9
分类专栏： JAVA基础进阶 文章标签： java
于 2023-03-10 21:22:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hdakj22/article/details/129400389
版权
文章详细介绍了Java中的Stream流，包括其在处理集合、数组和零散数据时的应用，以及如何通过中间方法（如filter、map）和终结方法（如forEach、collect）进行数据过滤、转换和收集。文章还提供了多个示例来演示Stream流简化代码和提高效率的功能。
摘要由CSDN通过智能技术生成

目录

一、 引言

二、 Stream流概述

三、Stream流的使用步骤

 1.  获取Stream流

1.1  单列集合

1.2  双列集合

1.3  数组

1.4  零散数据

2. Stream流的中间方法

3. Stream流的终结方法

四、 练习

1.  数据过滤

2.  数据操作 - 按年龄筛选

3. 数据操作 - 演员信息要求筛选

一、 引言

初识Stream流的作用：

需求：按照下面的要求完成集合的创建和遍历，创建一个集合，存储多个字符串元素

 通过下面代码，显然我们清晰的看到使用Stream流更为方便，而使用普通的集合遍历就有些复杂。

public class Test01 {
	public static void main(String[] args) {
		ArrayList<String> list1 = new ArrayList<>();
		list1.add("张无忌");
		list1.add("周正若");
		list1.add("赵斌");
		list1.add("张强");
		list1.add("张三丰");

		// Stream流
		list1.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3)
				.forEach(name -> System.out.println(name));
		// 张无忌
		// 张三丰

		// 1.把所有“张”姓开头元素存储到新集合
		ArrayList<String> list2 = new ArrayList<>();
		for (String name : list1) {
			if (name.startsWith("张")) {
				list2.add(name);
			}
		}
		System.out.println(list2); // [张无忌, 张强, 张三丰]

		// 2.把所有“张”姓开头且长度为3的元素存储到新集合
		ArrayList<String> list3 = new ArrayList<>();
		for (String name : list2) {
			if (name.length() == 3) {
				list3.add(name);
			}
		}
		System.out.println(list3); // [张无忌, 张三丰]
	}
}

二、 Stream流概述

例如上面的小例子，Stream流的思想如下：

顺序筛选

 Stream流的作用就是：

 结合了Lambda表达式，简化集合、数字的操作。

三、Stream流的使用步骤

  1. 先得到一条Stream流（流水线），并把数据放上去。
  2. 使用中间方法对流水线上的数据进行操作。
  3. 使用终结方法对流水线上的数据进行操作。
过滤、转换中间方法方法调用完毕之后，还可以调用其他方法
统计、打印终结方法最后一步，调用完毕之后，不能调用其他方法

 1.  获取Stream流

获取方式方法名说明
单列集合default  Stream<E>  stream()Collection中的默认方法
双列集合无

无法直接使用stream流，需要通过keySet()或者entrySet()变成单列集合

数组public  static <T>  Stream <T>  stream(T [ ] array)Arrays工具类中的静态方法
一堆零散数据public  static <T>  Stream <T>  of(T... values)stream接口中的静态方法

1.1  单列集合

public class StreamTest {
	public static void main(String[] args) {
		//单列集合获取Stream流
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "a","b","c","d","e");
		//获取到一个流水线，并把集合中的数据方法流水线上
		//Stream<String> stream1 = list.stream();
		//使用终结方法打印流水线上数据
		//stream1.forEach( s ->System.out.println(s) );
		
		list.stream().forEach(s -> System.out.println(s));
	}
}

1.2  双列集合

public class StreamTest {
	public static void main(String[] args) {
		
		//双列集合获取Stream流 
		//1. 创建双列集合
		HashMap<String, Integer> hm = new HashMap<>();
		//2. 添加数据
		hm.put("aaa", 111);
		hm.put("bbb", 222);
		hm.put("ccc", 333);
		//3.1 获取Stream流方法一： keySet()
		//键
		 hm.keySet().stream().forEach(s -> System.out.println(s));
		//3.2 获取Stream流方法二：entrySet()
		 //键值对
		hm.entrySet().stream().forEach(s -> System.out.println(s));	 
	}
}

1.3  数组

Stream接口中静态方法of的细节：

  • 方法的形参是一个可变参数，可以传递一堆零散数据，也可以传递数组。
  • 但是数组必须是引用数据类型。
  • 如果传递的是基本数据类型，是会把整个数组相当做一个元素，放到一个stream流当中。
public class StreamTest {
	public static void main(String[] args) {
		
		//数组获取Stream流 
		//1.创建基本数据类型数组
		int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
		//获取stream
		Arrays.stream(arr1).forEach(s -> System.out.println(s));
		
		//2.创建引用数据类型数组
		String[] arr2 = {"a","b","c"};
		//获取stream
		Arrays.stream(arr2).forEach(s -> System.out.println(s));
		
		//方式是错误的!!!
		//Stream接口中静态方法of的细节
		//方法的形参是一个可变参数，可以传递一堆零散数据，也可以传递数组
		//但是数组必须是引用数据类型
		//如果传递的是基本数据类型，是会把整个数组相当做一个元素，放到一个stream流当中
		Stream.of(arr2).forEach(s -> System.out.println(s));
		Stream.of(arr1).forEach(s -> System.out.println(s)); //[I@1b28cdfa
	}
}

1.4  零散数据

细节： 一堆零散数据需要是相同的数据类型。

public class StreamTest {
	public static void main(String[] args) {
		//零散数据获取Stream流 
		
		//基本数据类型
		Stream.of(1,2,3,4,5).forEach(s -> System.out.println(s));
		
		//引用数据类型
		Stream.of("a","b","c","d","e").forEach(s -> System.out.println(s));
	}
}

2. Stream流的中间方法

方法名称说明
Stream<T> filter ( Predicate<? super T>  predicate )过滤
Stream<T> limit ( long  maxSize)获取前几个元素
Stream<T> skip ( long  n )跳过前几个元素
Stream<T> distinct ( )元素去重，依赖(hashCode和equals方法)
static <T> Stream<T> concat ( Stream a ,  Stream b )合并a和b两个流为一个流
Stream<R> map ( Function<T ,R>  mapper )转换流中的数据类型

注意一：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程。

注意二：修改Stream流中的数据，不会影响原来集合或者数组中的数据。

public class StreamTest01 {
	public static void main(String[] args) {
		//1.过滤:把开头的留下，其余数据过滤不要
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "张三","李四","王五","赵六","张七");
		
		ArrayList<String> list2 = new ArrayList<>();
		Collections.addAll(list2, "张三","李四","王五","赵六","张三");
		
		ArrayList<String> list3 = new ArrayList<>();
		Collections.addAll(list3, "孙七","钱八");
		
		ArrayList<String> list4 = new ArrayList<>();
		Collections.addAll(list2, "张三-23","李四-24","王五-25");
		
		list.stream().filter(new Predicate<String>() {
			//匿名内部类太麻烦 需要缩写
			@Override
			public boolean test(String s) {
				//如果返回值为true,表示当前数据留下
				//如果返回值为false,表示当前数据舍弃
				return s.startsWith("张");
				
			}
		}).forEach(s -> System.out.println(s)); //张三 张七
		
		list.stream()
		    .filter(s -> s.startsWith("张"))
		    .forEach(s -> System.out.println(s));
		
		//2. 获取前几个元素  
		list.stream()
		    .limit(3)
		    .forEach(s -> System.out.println(s));  //张三 李四 王五
		//3. 跳过
		list.stream()
		    .skip(4)
		    .forEach(s -> System.out.println(s));  //张七
		
		//4.去重
		list2.stream()
		     .distinct()
		     .forEach(s -> System.out.println(s)); //张三 李四 王五 赵六
		
		//5. 合并
		Stream.concat(list2.stream(), list3.stream())
		      .forEach(s -> System.out.println(s));
		
		//6.转换数据类型
		//只能获取集合里面的年龄并打印
		//第一个类型：流中原本的数据类型
		//第二个类型：将要转变成为的数据类型
		list4.stream().map(new Function<String,Integer>() {
			@Override
			//apply: 依次表示流中的每一盒数据
			//返回值：表示转化之前的数据
			public Integer apply(String s) {
				String[] arr = s.split("-");
				String ageString = arr[1];
				int age = Integer.parseInt(ageString);
				return age;
			}
		}).forEach(s -> System.out.println(s));
		
		list.stream()
		    .map(s ->Integer.parseInt(s.split("-")[1]))
		    .forEach(s -> System.out.println(s));
	}
}

3. Stream流的终结方法

方法名称说明
void forEach ( Consumer action )遍历
long count ( )统计
toArray ( )收集流中的数据，放到数组中
collect ( Collector collector )收集流中的数据，放到集合中
public class StreamTest02 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "张三", "李四", "王五", "赵六");

		// 遍历

		// Consumer的泛型：表示流中的数据类型
		// accept方法的形参s：依次表示流中的每一个数据
		//
		list.stream().forEach(new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		});

		list.stream().forEach(s -> System.out.println(s)); // 张三 李四 王五 赵六

		// 统计
		long count = list.stream().count();
		System.out.println(count); // 4

		// 收集数据放进数组
		Object[] arr1 = list.stream().toArray();
		System.out.println(Arrays.toString(arr1)); // [张三, 李四, 王五, 赵六]

		// 指定数据类型
		// Infunction的泛型：具体类型的数组
		// apply中形参：流中数据的个数，要跟数组长度一致
		// apply的返回值：具体类型的数组
		String[] arr2 = list.stream().toArray(new IntFunction<String[]>() {
			@Override
			public String[] apply(int value) {
				return new String[value];
			}
		});
		// toArray方法中的参数：只是创建一个指定类型的数组
		// toArray底层： 会此意得到流中的每一个数据，并把数据放到数组中
		// toArray的返回值：是一个装着流里面所有数据的数组
		System.out.println(Arrays.toString(arr2));

		// lambda表达式
		String[] arr3 = list.stream().toArray(value -> new String[value]);
		System.out.println(Arrays.toString(arr3));
	}
}

 collect方法：

public class StreamTest {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "张三-男-23", "李四-男-24", 
                        "王五-男-25", "赵六-女-27", "孙八-女-28");

		//收集到List集合当中
		//需求：
		//将所有的男性收集起来
		List<String> newList = list.stream()
				.filter(s-> "男".equals(s.split("-")[1]))
				.collect(Collectors.toList());
		System.out.println(newList);  //[张三-男-23, 李四-男-24, 王五-男-25]
		
		//收集到Set集合当中
		Set<String> newSet = list.stream()
				.filter(s-> "男".equals(s.split("-")[1]))
				.collect(Collectors.toSet());
		System.out.println(newSet);
		
		//收集到Map集合当中
		//键： 姓名  值： 年龄
		
		//toMap：
		//参数一表示键的生成规则  参数二表示值得生成规则
		//参数一：  
		//Function泛型一：表示流中每一个数据的类型 ；
		//        泛型二：表示Map集合中键的数据类型
		//方法apply 形参：一次表示流里面的每一个数据
		//        方法体：生成键的代码 
		//        返回值：已生成的键
		//参数二：
		//Function泛型一：表示流中每一个数据的类型 ；
		//        泛型二：表示Map集合中值的数据类型
		//方法apply 形参：一次表示流里面的每一个数据
		//        方法体：生成值的代码 
		//        返回值：已生成的值
		Map<String, Integer> newMap = list.stream()
		.filter(s-> "男".equals(s.split("-")[1]))
		.collect(Collectors.toMap(new Function<String, String>() {
			@Override
			public String apply(String s) {
				return s.split("-")[0];
			}
		}, new Function<String, Integer >() {
			@Override
			public Integer apply(String s) {
				return Integer.parseInt(s.split("-")[2]);
			}
		}));
		System.out.println(newMap);  //{李四=24, 张三=23, 王五=25}
		
		//lambda表达式
		Map<String, Integer> newMap1 = list.stream()
				.filter(s-> "男".equals(s.split("-")[1]))
				.collect(Collectors.toMap( 
						s-> s.split("-")[0], 
						s-> Integer.parseInt(s.split("-")[2])));
		System.out.println(newMap1);
	}
}

四、 练习

1.  数据过滤

需求：

定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10

过滤奇数，只留下偶数。
并将结果保存起来

public class StreamDemo {
	public static void main(String[] args) {
		// 1.定义一个集合
		ArrayList<Integer> list = new ArrayList<>();
		// 2.添加数据
		Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

		// 3.过滤奇数，只留偶数
		// 进行判断，如果是偶数，返回true
		List<Integer> list2 = list.stream()
				.filter(n -> n % 2 == 0)
				.collect(Collectors.toList());
		System.out.println(list2); //[2, 4, 6, 8, 10]
	}
}

2.  数据操作 - 按年龄筛选

需求：
创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄

      “zhangsan，23”
      “lisi，24"
      “wangwu，25”
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值

public class StreamDemo {
	public static void main(String[] args) {
		// 1.定义一个集合
		ArrayList<String> list = new ArrayList<>();
		//2.集合添加字符串
		list.add( "zhangsan,23");
		list.add("lisi,24");
		list.add("wangwu,25");
		//3.保留年龄大于24岁的人
		Map<String, Integer> map = list.stream()
		.filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
		.collect(Collectors.toMap(
				s -> s.split(",")[0], 
				s -> Integer.parseInt(s.split(",")[1])));
		System.out.println(map);  //{lisi=24, wangwu=25}
	}
}

3. 数据操作 - 演员信息要求筛选

现在有两个ArrayList集合，
第一个集合中：存储6名男演员的名字和年龄。第二个集合中:存储6名女演员的名字和年龄。姓名和年龄中间用逗号隔开。比如：张三，23
要求完成如下的操作:

  1. 男演员只要名字为3个字的前两人
  2. 女演员只要姓杨的，并且不要第一个
  3. 把过滤后的男演员姓名和女演员姓名合并到一起
  4. 将上一步的演员信息封装成Actor对象。
  5. 将所有的演员对象都保存到List集合中。

备注：演员类Actor，属性有：name,age

public class StreamDemo {
	public static void main(String[] args) {
		// 1.定义两个集合
		ArrayList<String> manList = new ArrayList<>();
		ArrayList<String> womenList = new ArrayList<>();

		// 2.添加数据
		Collections.addAll(manList, "蔡坤坤,24", "叶购成,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");
		Collections.addAll(womenList, "赵小颖,35", "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33");

		// 3. 男演员只要名字为3个字的前两个人
		Stream<String> stream1 = manList.stream()
		.filter(s -> s.split(",")[0].length() == 3)
		.limit(2);
//		.forEach(s -> System.out.println(s)); // 蔡坤坤,24  叶购成,23
																													// 叶购成,23
		//4.女演员只要姓杨的 并且不要第一个
		Stream<String> stream2 = womenList.stream()
		.filter(s -> s.split(",")[0].startsWith("杨"))
		.skip(1);
//		.forEach(s -> System.out.println(s));  //杨小幂,33
		
		//5.把过滤的男演员和女演员信息合并在一起
		//演员信息封装进Actor对象
		
		//String -> Actor对象（类型转换）
		List<Actor> list = Stream.concat(stream1, stream2)
		.map(s -> new Actor(s.split(",")[0],Integer.parseInt(s.split(",")[1])))
		.collect(Collectors.toList());
		System.out.println(list);
	}
}
Hgngy.
关注
专栏目录
黑马程序员入学Java知识——精华总结
03-07
"黑马程序员入学Java知识——精华总结"这份文档很可能包含了Java编程的基础到进阶的知识点，旨在帮助初学者快速掌握Java的核心概念和技能。 1. **Java基础知识**：Java是一种面向对象的语言，它的基础包括语法、...
Stream流详解
ss810540895的博客
08-05 3万+
stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。............
Java8中的Stream API详解:Stream的背景及使用
Rico's Blogs
03-15 8万+
摘要： 　　 　　Stream是Java8的一大亮点，是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的 聚合操作（aggregate operation）或者大批量数据操作。Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来...
java---Stream流
最新发布
weixin_64689713的博客
09-20 1145
Java中的Stream API 是Java 8中引入的一个关键抽象概念，它允许你以声明方式处理数据集合（包括数组、集合等）。Stream API提供了一种高效且易于使用的方式来处理数据序列，包括过滤、映射、排序、归约等操作。使用Stream API可以使代码更加简洁、易于理解和维护。
Java--Stream流详解
MinggeQingchun的博客
08-30 8万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java - Stream流详解
weixin_73869209的博客
06-05 2万+
Stream流是Java 8中的一个新特性，它提供了一种处理集合和数组的方式。Stream流可以让我们以一种更加简洁、高效、可读性更强的方式来处理数据。Stream流可以用于过滤、映射、排序、聚合等操作，它可以让我们避免使用循环和条件语句来处理数据，从而让代码更加简洁易懂。Stream流的操作可以分为中间操作和终止操作两种类型，中间操作返回的是一个新的Stream流，终止操作返回的是一个非Stream类型的结果。Stream流的处理是惰性求值的，只有在执行终止操作时才会开始处理数据。
Java中Stream流详解
weixin_52357829的博客
06-12 1万+
Stream是Java 8中非常重要的一个API，可以极大地方便我们对列表、集合等数据源进行连续操作。Stream操作可以极大地简化我们的代码，提高效率，因此在Java编程中应该熟练使用Stream。需要注意的是，在对Stream进行操作时，应该注意Stream的惰性计算特性，以避免不必要的计算开销。
java面试宝典-150页
02-13
这份150页的宝典涵盖了Java编程的基础知识、进阶概念以及实际开发中的常见问题，是Java程序员面试必备的学习资料。 在Java面试中，通常会涉及以下几个核心知识点： 1. **Java基础**：这是面试的基础部分，包括Java...
Java语言程序设计-进阶篇（原书第8版）
03-07
总结上述信息，我们可以提炼出以下Java进阶知识点，这些可能是《Java语言程序设计-进阶篇（原书第8版）》一书中将要讨论的重点： 1. Java多线程编程：理解Java的并发模型，掌握线程的创建与管理，了解同步机制和...
java成神之路思维导图——Hollis.zip
05-14
这个思维导图可能还包含了一些进阶主题，如Java 8及更高版本的新特性，例如Lambda表达式、Stream API、Optional等。此外，也可能涉及到分布式系统、微服务架构、容器化（Docker）和云服务（如AWS、Azure、Google ...
java语言程序设计（上册+下册）
03-08
**下册——Java语言程序设计-进阶篇（原书第8版）** 进阶篇则更侧重于高级主题和技术，包括： 1. **高级面向对象编程**：深入探讨接口、内部类、匿名类、枚举，以及抽象类和设计模式的应用。 2. **IO与NIO**：...
Java-Stream详解
yueerba126的博客
06-30 7824
Stream是Java 8新增的接口，Stream可以认为是一个高级版本的 Iterator。
Java 8 stream的详细用法
热门推荐
旅行者
01-08 29万+
一、概述 Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。 特点：         1 . 不是...
Java---Stream流技术（全网最详细）
qq_64847107的博客
07-30 8466
流是Java 8 API添加的一个新的抽象，称为流Stream，以一种声明性方式处理数据集合（侧重对于源数据计算能力的封装，并且支持序列与并行两种操作方式）Stream流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算Stream流是对集合（Collection）对象功能的增强，与结合，可以提高编程效率、间接性和程序可读性。
Java——Stream流
candycrush_CL的博客
07-18 2736
Java——Stream流 stream是数据渠道，用于操作数据源（集合、数组）所生产的元素序列。这一类操作称作局和操作，它的基本流程是： ​ 1、将原始数据或数组对象转换为stream流。 ​ 2、对stream流中的元素进行一系列的过滤、查找等中间操作(Intermediate Operations)，然后 仍返回一个Stream流对象 ​ 3、对stream流进行统计、遍历、收集等终结操作（Terminal Operation）获取想要的结果。 Stream流有以下的特点： stream是不能存储
Java的Stream流详细讲解
qq_45443475的博客
06-28 1万+
Java的Stream流详细讲解
【Java 8系列】Stream详解，看这一篇就够啦
Yangy的博客
12-23 5万+
热门系列： 【Java 8系列】Java开发者的判空利器 -- Optional 【Java 8系列】Lambda 表达式，一看就废 程序人生，精彩抢先看 1.前言 2.正文 3.总结 ...
Stream流
洱涷zZ的博客
05-17 3287
Stream流式编程思想 ​ --洱涷 （1）什么是Stream Stream是一种流，是一种抽象的处理数据的思想，这种编程方式将要处理的元素集合看作一种流，流在管道中传输，然后在管道的每一个节点上对流进行操作（去重，分组，过滤…），元素流在经过管道的操作后，最后由最终操作得到新的一个元素集合。 Stream是一个来自数据源的元素队列并支持聚合操作 元素是特定类型的对象所形成的一个队列，Stream并不会去储存元素，而是按照需求所进行元素计算等操作 数据源流的来
java中的stream基本使用
m0_51628911的博客
03-24 1640
java中stream流的基本使用
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Hgngy.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值