字符字节流

于 2022-10-24 21:13:23 发布
阅读量114 收藏
点赞数
分类专栏： java 文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dd_Mr/article/details/127501705
版权
本文详细介绍了Java中的IO技术，包括File类的使用，如构造方法、静态成员变量、文件和目录的操作，以及相对路径和绝对路径的区别。此外，还讲解了递归的概念，并通过实例展示了如何递归遍历目录，查找特定类型的文件。最后，通过文件过滤器实现了对目录下特定后缀名文件的筛选。
摘要由CSDN通过智能技术生成

今日内容介绍
1、File
2、递归

=第一节课开始=======================

###01IO技术概述.avi（02:49）
* A:IO技术概述
* a: Output
* 把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作
* b: Input
* 把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操作
* c: IO操作
* 把上面的这种输入和输出动作称为IO操作

###02File类的概述和作用
* A:File类的概述和作用
* a: File的概念
* File类是文件和目录路径名的抽象表示形式
* Java中把文件或者目录（文件夹）都封装成File对象
* 我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可

###03File类静态的成员变量
* A:File类静态的成员变量
* a: pathSeparator
* 与系统有关的路径分隔符，为了方便，它被表示为一个字符串
* b: separator
* 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串

	* c: 案例代码
	
		/*
		 *  java.io.File
		 *    将操作系统中的,文件,目录(文件夹),路径,封装成File对象
		 *    提供方法,操作系统中的内容
		 *    File与系统无关的类
		 *    文件 file
		 *    目录 directory
		 *    路径 path
		 */
		public class FileDemo {
			public static void main(String[] args) {
				//File类静态成员变量
				//与系统有关的路径分隔符
				String separator = File.pathSeparator;
				System.out.println(separator);// 是一个分号,目录的分割(window中环境变量配置各个路径用分号分割，表示一个完整的路径结束)  Linux中是冒号 :
				
				//与系统有关的默认名称分隔符
				separator = File.separator;
				System.out.println(separator);// 向右 \  目录名称分割  Linux / 
			}
		}

​

###04File类构造方法_1
* A: File类构造方法_1
* a: File(String pathname)
* 通过将给定路径名字符串转换为一个File对象,之后可以使用File中的方法
* windows中的路径或文件名不区分大小写
* d: 案例代码
public class FileDemo1 {
public static void main(String[] args) {
function();
}
/*
* File(String pathname)
* 传递路径名: 可以写到文件夹,可以写到一个文件
* c:\abc c:\abc\Demo.java
* 将路径封装File类型对象
*/
public static void function(){
File file = new File(“d:\eclipse”);
System.out.println(file);
}
}

###05相对路径和绝对路径
* A: 相对路径和绝对路径
* a: 绝对路径
* 绝对路径是一个固定的路径,从盘符开始
* b: 相对路径
* 相对路径相对于某个位置,在eclipse下是指当前项目下
* c: 路径
绝对路径
在系统中具有唯一性
c:\windows\system32
相对路径
表示路径之间的关系
D:\develop\Java\jdk1.7.0_72\bin
D:\develop\Java\jre7
路径之间关系
Java 父目录是D:\develop
Java 子目录是：jdk1.7.0_72
父路径是 唯一性
子目录是可以多个

​
###06File类的构造方法_2
​ * A: File类的构造方法_2
​ * a:File(String parent, String child)
​ * 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 对象
​

	* b: File(File parent, String child)
	
	* c: 案例代码
	public class FileDemo1 {
		public static void main(String[] args) {
			function_2();
		}
		/*
		 *  File(File parent,String child)
		 *  传递路径,传递File类型父路径,字符串子路径
		 *  好处: 父路径是File类型,父路径可以直接调用File类方法
		 */
		public static void function_2(){
			File parent = new File("d:");
			File file = new File(parent,"eclipse");
			System.out.println(file);
		}
		
		/*
		 *  File(String parent,String child)
		 *  传递路径,传递字符串父路径,字符串子路径
		 *  好处: 单独操作父路径和子路径
		 */
		public static void function_1(){
			File file = new File("d:","eclipse");
			System.out.println(file);
		}
	}

​
###07File类创建文件功能
​ * A: File类创建文件功能
​ * a: public boolean createNewFile()
​ * 创建文件 如果存在这样的文件，就不创建了
​

	* b: 案例代码
		public class FileDemo2 {
			public static void main(String[] args)throws IOException {
				function();
			}						
			/*
			 *  File创建文件的功能
			 *  boolean createNewFile()
			 *  创建的文件路径和文件名,在File构造方法中给出
			 *  文件已经存在了,不在创建
			 */
			public static void function()throws IOException{
				File file = new File("c:\\a.txt");
				boolean b = file.createNewFile();
				System.out.println(b);
			}
		}

​
###08File类创建目录功能
​ * A: File类创建目录功能
​ * a: 创建目录
​ * public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
​ * public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
​ * b: 案例代码
​ public class FileDemo2 {
​ public static void main(String[] args)throws IOException {
​ function_1();
​ }
​ /*
​ * File创建文件夹功能
​ * boolean mkdirs() 创建多层文件夹
​ * 创建的路径也在File构造方法中给出
​ * 文件夹已经存在了,不在创建
​ */
​ public static void function_1(){
​ File file = new File(“c:\abc”);
​ boolean b = file.mkdirs();
​ System.out.println(b);
​ }
​ }

###09File类删除功能
* A: File类删除功能
* a: 删除功能
* public boolean delete():删除文件或者文件夹
* B: 案例代码
public class FileDemo2 {
public static void main(String[] args)throws IOException {
function_2();
}
/*
* File类的删除功能
* boolean delete()
* 删除的文件或者是文件夹,在File构造方法中给出
* 删除成功返回true,删除失败返回false
* 删除方法,不走回收站,直接从硬盘中删除
* 删除有风险,运行需谨慎
*/
public static void function_2(){
File file = new File(“c:\a.txt”);
boolean b = file.delete();
System.out.println(b);
}
}

###10File类获取功能
* A：File类获取功能
* a: 方法介绍
* String getName(): 返回路径中表示的文件或者文件夹名
* 获取路径中的最后部分的名字
* long length(): 返回路径中表示的文件的字节数
* String getAbsolutePath(): 获取绝对路径,返回String对象
* File getAbsoluteFile() : 获取绝对路径,返回File对象
* eclipse环境中,写一个相对路径,绝对位置工程根目录
* String getParent(): 获取父路径,返回String对象
* File getParentFile(): 获取父路径,返回File对象

	* b: 案例代码
	
		public class FileDemo3 {
			public static void main(String[] args) {
				function_3();
			}
			/*
			 * File类的获取功能
			 * String getParent() 返回String对象
			 * File getParentFile()返回File对象
			 * 获取父路径
			 */
			public static void function_3(){
				File file = new File("d:\\eclipse\\eclipse.exe");
				File parent = file.getParentFile();
				System.out.println(parent);
			}
			
			/*
			 * File类获取功能
			 * String getAbsolutePath() 返回String对象
			 * File   getAbsoluteFile() 返回File对象
			 * 获取绝对路径
			 * eclipse环境中,写的是一个相对路径,绝对位置工程根目录
			 */
			public static void function_2(){
				File file = new File("src");
				File absolute = file.getAbsoluteFile();
				System.out.println(absolute);
			}
			
			/*
			 * File类获取功能
			 * long length()
			 * 返回路径中表示的文件的字节数
			 */
			public static void function_1(){
				File file = new File("d:\\eclipse\\eclipse.exe");
				long length = file.length();
				System.out.println(length);
			}
			
			/*
			 *  File类的获取功能
			 *  String getName()
			 *  返回路径中表示的文件或者文件夹名
			 *  获取路径中的最后部分的名字
			 */
			public static void function(){
				File file = new File("d:\\eclipse\\eclipse.exe");
				String name = file.getName();
				System.out.println(name);
				
				/*String path = file.getPath();
				System.out.println(path);*/
		//		System.out.println(file);
			}
		}

​
###11File类判断功能
​ * A: File类判断功能
​ * a: 方法介绍
​ * boolean exists(): 判断File构造方法中封装路径是否存在
​ * 存在返回true,不存在返回false
​ * boolean isDirectory(): 判断File构造方法中封装的路径是不是文件夹
​ * 如果是文件夹,返回true,不是文件返回false
​ * boolean isFile(): 判断File构造方法中封装的路径是不是文件
​ * 如果是文件,返回true,不是文件返回false
​

	* b: 案例代码
		public class FileDemo4 {
			public static void main(String[] args) {
				function_1();
			}
			/*
			 *  File判断功能
			 *  boolean isDirectory()
			 *  判断File构造方法中封装的路径是不是文件夹
			 *  如果是文件夹,返回true,不是文件返回false
			 *  
			 *  boolean isFile()
			 *  判断File构造方法中封装的路径是不是文件
			 */
			public static void function_1(){
				File file = new File("d:\\eclipse\\eclipse.exe");
				if(file.exists()){
					boolean b = file.isDirectory();
					System.out.println(b);
				}
			}
			
			/*
			 *  File判断功能
			 *  boolean exists()
			 *  判断File构造方法中封装路径是否存在
			 *  存在返回true,不存在返回false
			 */
			public static void function(){
				File file = new File("src");
				boolean b = file.exists();
				System.out.println(b);
			}
		}

###12File类list获取功能
* A: File类list获取功能
* a: 方法介绍
* String[] list()：获取到File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
* 返回只有名字
* File[] listFiles()：获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
* 返回的是目录或者文件的全路径
* static File[] listRoots(): 列出可用的文件系统根

	* b: 案例代码
		public class FileDemo {
			public static void main(String[] args) {
				function_2();
			}
			public static void function_2(){
				//获取系统中的所有根目录
				File[] fileArr = File.listRoots();
				for(File f : fileArr){
					System.out.println(f);
				}
			}
			
			/*
			 *  File类的获取功能
			 *  File[] listFiles()
			 *  获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
			 *  返回的是目录或者文件的全路径
			 */
			public static void function_1(){
				File file = new File("d:\\eclipse");
				File[] fileArr = file.listFiles();
				for(File f : fileArr){
					System.out.println(f);
				}
			}
			
			/*
			 *  File类的获取功能
			 *  String[] list()
			 *  获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
			 *  返回只有名字
			 */
			public static void function(){
				File file = new File("c:");
				String[] strArr = file.list();
				System.out.println(strArr.length);
				for(String str : strArr){
					System.out.println(str);
				}
			}
		}

###13文件过滤器
* A: 文件过滤器
* a: 作用
* 过滤一个目录下的指定扩展名的文件，或者包含某些关键字的文件夹

	* b: 方法介绍
		* public String[] list(FilenameFilter filter)
		* public File[] listFiles(FileFilter filter)
		
	* C: 案例代码	
		/*
		 *  自定义过滤器
		 *  实现FileFilter接口,重写抽象方法
		 */
		public class MyFilter implements FileFilter{
			public boolean accept(File pathname)  {
				/*
				 * pathname 接受到的也是文件的全路径
				 * c:\\demo\\1.txt
				 * 对路径进行判断,如果是java文件,返回true,不是java文件,返回false
				 * 文件的后缀结尾是.java
				 */
				//String name = pathname.getName();
				return pathname.getName().endsWith(".java");
				
			}
		}
		
		/*
		 *  File类的获取,文件获取过滤器
		 *  遍历目录的时候,可以根据需要,只获取满足条件的文件
		 *  遍历目录方法 listFiles()重载形式
		 *  listFiles(FileFilter filter)接口类型
		 *  传递FileFilter接口的实现类
		 *  自定义FileFilter接口实现类,重写抽象方法,
		 *  接口实现类对象传递到遍历方法listFiles
		 */
		public class FileDemo1 {
			public static void main(String[] args) {
				File file = new File("c:\\demo");
				File[] fileArr = file.listFiles(new MyFilter());
				for(File f : fileArr){
					System.out.println(f);
				}
			}
		}

###14文件过滤器_原理分析
* A:文件过滤器_原理分析
* listFiles()遍历目录的同时，获取到了文件名全路径，调用过滤器的方法accept，将获取到的路径传递给accept方法的参数pathname
* accept方法接收了参数pathname，参数是listFiles传递来的
* 在accept方法中，进行判断，如果这个路径是Java文件，返回true，走着返回false
* 一旦方法返回了true
* listFiles将路径保存到File数组中

###15递归遍历全目录
* A: 递归遍历全目录
* a: 案例代码
/*
* 对一个目录的下的所有内容,进行完全的遍历
* 编程技巧,方法的递归调用,自己调用自己
/
public class FileDemo {
public static void main(String[] args) {
File dir = new File(“d:\eclipse”);
getAllDir(dir);
}
/
* 定义方法,实现目录的全遍历
*/
public static void getAllDir(File dir){
System.out.println(dir);
//调用方法listFiles()对目录,dir进行遍历
File[] fileArr = dir.listFiles();
for(File f : fileArr){
//判断变量f表示的路径是不是文件夹
if(f.isDirectory()){
//是一个目录,就要去遍历这个目录
//本方法,getAllDir,就是给个目录去遍历
//继续调用getAllDir,传递他目录
getAllDir(f);
}else{
System.out.println(f);
}
}
}
}

​
###16递归概念和注意事项
​ * A:递归概念和注意事项
​ * a: 递归概念
​ * 递归，指在当前方法内调用自己的这种现象
​ * 递归分为两种，直接递归和间接递归
​ * 直接递归称为方法自身调用自己。间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法
​ * b: 注意事项
​ * 递归一定要有出口, 必须可以让程序停下
​ * 递归次数不能过多
​ * 构造方法,禁止递归
​
###17递归求和计算
​ * A: 递归求和计算
​ * a: 题目分析
​ * 1+2+3+…+(n-1)+n:求1到n的和
​ * 总结规律：1到n的和等于1到(n-1)的和再加n
​ * getSum(n-1)+ n
​ * 递归出口：getSum(1) return 1;
​

	* b: 案例代码	
		/*
		 *  方法的递归调用
		 *    方法自己调用自己
		 *  适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化
		 *  注意:
		 *     递归一定要有出口, 必须可以让程序停下
		 *     递归次数不能过多
		 *     构造方法,禁止递归
		 */
		public class DiGuiDemo {
			public static void main(String[] args) {
				int sum = getSum(3);
				System.out.println(sum);
			}

​

			/*
			 *  计算 1+2+3+100和 = 5050
			 *  计算规律:
			 *    n+(n-1)+(n-2)
			 *    100+(100-1)+(99-1)+...1
			 */
			public static int getSum(int n){
				if( n == 1)
					return 1;
				return n + getSum(n-1);
			}
			
		}

###18递归求阶乘
* A: 递归求和计算
* a: 题目分析
* 5!=54321
* =54!
* 4!=43!
* 3!=32!
* 2!=21!
* 1!=1
* n!=n*(n-1)!
* 递归出口：ngetJieCheng(n-1): getJieCheng(1) return 1;
* b: 案例代码
/
* 方法的递归调用
* 方法自己调用自己
* 适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化
* 注意:
* 递归一定要有出口, 必须可以让程序停下
* 递归次数不能过多
* 构造方法,禁止递归
*/
public class DiGuiDemo {
public static void main(String[] args) {
System.out.println(getJieCheng(5));

			}
							
			/* 
			 *  计算阶乘 5!
			 *   5*4*3*2*1
			 */
			public static int getJieCheng(int n){
				if ( n == 1)
					return 1;
				return n * getJieCheng(n-1);
			}								
		}

###19递归计算斐波那契数列
* A: 递归计算斐波那契数列
* a：题目分析
* 1 1 2 3 5 8 13 21
* 从第三项开始，后面的每一项都等于前面两项的和，第一项和第二项的值为1，作为程序的出口
* b: 案例代码
/*
* 方法的递归调用
* 方法自己调用自己
* 适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化
* 注意:
* 递归一定要有出口, 必须可以让程序停下
* 递归次数不能过多
* 构造方法,禁止递归
/
public class DiGuiDemo {
public static void main(String[] args) {
System.out.println(getFBNQ(12));
}
/
* 方法递归,计算斐波那契数列
*
*/
public static int getFBNQ(int month){
if( month == 1)
return 1;
if( month == 2)
return 1;
return getFBNQ(month-1)+getFBNQ(month-2);
}
}
###20遍历目录下的所有java文件
* A: 遍历目录下的所有java文件
* a: 案例代码
public class MyJavaFilter implements FileFilter {
public boolean accept(File pathname) {
//判断获取的是目录,直接返回true
if(pathname.isDirectory())
return true;
return pathname.getName().toLowerCase().endsWith(“.java”);
}

		}
		/*
		 *  遍历目录,获取目录下的所有.java文件
		 *  遍历多级目录,方法递归实现
		 *  遍历的过程中,使用过滤器
		 */
		public class FileDemo1 {
			public static void main(String[] args) {
				getAllJava(new File("c:\\demo"));
		//		new File("c:\\demo").delete();
			}
			/*
			 * 定义方法,实现遍历指定目录
			 * 获取目录中所有的.java文件
			 */
			public static void getAllJava(File dir){
				//调用File对象方法listFiles()获取,加入过滤器
				File[] fileArr = dir.listFiles(new MyJavaFilter());
				for(File f : fileArr){
					//对f路径,判断是不是文件夹
					if(f.isDirectory()){
						//递归进入文件夹遍历
						getAllJava(f);
					}else{
						System.out.println(f);
					}
				}
			}
		}

###21总结
* 把今天的知识点总结一遍。

菠萝味菠萝啤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IO基础知识
wj328286902的博客
09-13 128
IO基础知识
字节流和字符流
12-22
字节流与字符流在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream，在字符流中输出主要是使用Writer类...
java之 IO之File
Walden_tinghou的专栏
04-12 566
01IO技术概述 * A:IO技术概述 * a: Output * 把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作 * b: Input * 把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操作 * c: IO操作 * 把上面的这种输入和输出动作称为IO操作 02File类的
IO的基础认识
不做程序员的博客
11-15 2035
一、IO的定义 IO 即IN“”和“OUT”的组合，IO流用来处理设备之间的数据传输，Java程序中，对于数据的输入/输出操作 都是以“流”的方式进行的。java.io包下提供了各种“流”类的接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。 比如我们常用的System.out.print（）就是io的应用 二、IO汇总 按照流的方向（输出输入都是站在程序所在内存的角度划分的）： 输入...
理解Java中字符流与字节流的区别
12-22
1. 什么是流 ...Java中基本的两个字节流类是InputStream和OutputStream，它们分别代表了组基本的输入字节流和输出字节流。InputStream类与OutputStream类均为抽象类，我们在实际使用中通常使用Java类库中提
Java字符流与字节流区别
01-07
Java 流在处理上分为字符流和字节流。字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。 Java 内用 Unicode 编码存储字符，字符流...
详解Java中字符流与字节流的区别
09-02
根据处理的数据单位，Java提供了两种主要类型的流：字符流和字节流。这两种流在处理数据时有显著的区别，尤其是在处理文本数据和二进制数据时。 1. 什么是流 流在Java中是一个抽象概念，它描述了数据如何从一个地方...
004-Netty核心技术及源码剖析-IO模型
zouxuhang的博客
09-28 198
文章目录I/O 模型基本说明BIO、NIO、AIO适用场景分析 I/O 模型基本说明 I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能 Java共支持3种网络编程模型/IO模式：BIO、NIO、AIO Java BIO ： 同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 【简单示意图】 Java NIO ： 同步非阻塞，服务器实现
file1
潮湿的桥
09-25 747
VC打开文件对话框2007-12-26 18:19try { CString str("",10000);//这是做为存放打开文件名和路径的字符串空间10000这个值的设置就觉得有些不妥当    CFileDialog openfile(true,NULL,NULL,     OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_ALLOWMULTISELECT,"Al
【Java学习笔记】——IO基础知识
名侦探张六儿的博客
08-14 315
    最近准备学习NIO与Netty相关的知识，但是尴尬地发现自己已经把IO的基本知识忘得差不多了，于是拿出以前的Java基础的书重新学习了一遍，记此博客作为笔记。 一、访问文件和目录     File类可以使用文件路径字符串来创建File实例，该路径既可以是绝对路径，也可以是相对路径。在默认情况下系统会按照用户的工作路径来作为相对路径，这个路径由系统属性“user.dir”指定，通常也就是...
IO基础
liuzewei2015的博客
05-04 84
对象序列化机制允许把内存中的java对象转化为平台无关的二进制流，从而允许把这种二进制流持久地保存到磁盘中，或通过网络将这种二进制流传输到另一个网络节点（序列化）。当其他程序获取了这种二进制流，就可以恢复成原来的java对象（反序列化）。 ObjectOutputStream与ObjectIntputStream：序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，将...
Java输入输出流
liian_q的专栏
02-05 545
来自慕课网Cedra老师 I/O视频的笔记 http://www.imooc.com/space/teacher/id/321949 编码问题 GBK 中文占两个字节 UTF-8 中文占3个字节 Java是双字节编码UTF-16be  当你的字节序列化某种编码时，这个时候想把字节序列化变成字符串，也需要用这种编码方式。 I/O File类只用于表示文件（
Java 高级—— IO 基础
知秋一叶
01-26 1613
一、File 类 先看一下File 类的定义 public class File extends Object implements Serizliable Comparable 从定义看，File类是Object的直接子类，同时它继承了Comparable接口可以进行数组的排序。 File类的操作包括文件的创建、删除、重命名、得到路径、创建时间等，以下是文件操作常用的函数。   Fi
IO-基础
birdswillbecomdragon的博客
04-26 177
现代计算机主存和cpu之间会构建多级高速缓存，L1、L2、L3等。CPU尽可能从L1获取数据，只要3秒，L1尽可能从L2获取数据，只要14秒，同样L2->L3，L3->内存，大幅度提升CPU与主存之间交互带来性能损耗，那么什么样的数据会存储到L1、L2、L3中，还有就是数据可见性的问题，有了多级的高速缓存，cpu就不用到主存中获取数据，若此时数据修改，如何得到正确的数据。 IO的操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值