一篇学会JavaIO流（输入输出流）

最新推荐文章于 2023-03-03 15:13:14 发布
最新推荐文章于 2023-03-03 15:13:14 发布
阅读量306 收藏
点赞数 1
分类专栏： 21天学习Java基础 文章标签： File类 io流的划分与区别 常用的字节输入与字节输出流类 序列化与反序列化 常用的字符输入与字符输出流类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qibulemingzi/article/details/126360235
版权

活动地址：CSDN21天学习挑战赛

输入输出流
  就是对文件进行读【打开】写【修改】操作的java类库
文件
  就是把数据持久化到磁盘的载体
文件的组成

  1.文件的属性【文件名称，文件大小，文件类型，创建时间…】
  2.文件内容【输入输出流】

  我们要想通过java提供的输入输出流读写文件中的内容就得先学会操作文件。
  Java中为我们提供了一个专门操作文件的java类 —> java.io.File类

一、File类的对象创建和常用方法

File类的定义

public class File

File类的静态成员变量

static StringpathSeparator 与系统相关的路径分隔符字符，为方便起见，表示为字符串
static charpathSeparatorChar 与系统相关的路径分隔符
static Stringseparator 与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串
static charseparatorChar 与系统相关的默认名称分隔符
例如：
package com.wangxing.test1;
import java.io.File;
public class TestFile1 {
	public static void main(String[] args) {
		//static String	pathSeparator 与系统相关的路径分隔符字符，为方便起见，表示为字符串。 
		//static char	pathSeparatorChar 与系统相关的路径分隔符。 
		//static String	separator 与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。 
		//static char	separatorChar 与系统相关的默认名称分隔符。 
		System.out.println("static String	pathSeparator=="+File.pathSeparator);
		System.out.println("static char	pathSeparatorChar=="+File.pathSeparatorChar);
		System.out.println("static  String	separator=="+File.separator);
		System.out.println("static char	separatorChar=="+File.separatorChar);
		//separator/separatorChar---路径分割符号【\】
		//假设我输出一个文件的路径【F:\test\name.text】
		System.out.println("文件的路径--F:\test\name.text");
		//此时我们输出的文件路径不正确，因为java程序将字串中的“\t”解释成制表符,
		//将“\n”解释成了回车输出，此时我们就无法正确的输出/描述一个文件路径。
		//我们要怎么办，可以通过“\\”将文件的路径分割符转义。
		System.out.println("文件的路径--F:\\test\\name.text");
		//既然我们可以通过“\\”转义路径分隔符，那么为什么还需要File类提供静态成员变量来表示路径分割符？？？
		//原因1:在=使用的时候并不全知道"\"与哪一个字母组合就会是一个特殊字符。
		//原因2：不同的计算机操作系统的路径分割符是不一样  例如"\"windows操作系统分隔符   "/"Linux分隔符.
		//为了不配特殊字符和可以在任何操作系统上完整的表示一个路径分割符号，
		//所以java就将路径分割符号做成了静态成员变量,以适应不同的操作系统和排除特殊字符。
		System.out.println("文件的路径--F:"+File.separator+"test"+File.separator+"name.text");
	}
}

运行结果：

在这里插入图片描述
构造方法：

File(String pathname)通过给定的文件路径字符串创建新的 File实例
File(String parent, String child)通过给定的文件位置字符串和给定的文件名称字符串创建新的 File实例
File(File parent, String child)通过给定的文件位置File对象和给定的文件名称字符串创建新的 File实例
例如：
package com.wangxing.test1;
import java.io.File;
public class TestFile2 {
	public static void main(String[] args) {
		//File(String pathname) 通过给定的文件路径字符串创建新的 File实例。
		String filepath1="F:"+File.separator+"test"+File.separator+"names.text";
		File file1=new File(filepath1);
		//File(String parent, String child) 通过给定的文件位置字符串和给定的文件名称字符串创建新的 File实例。 
		String  path1="F:"+File.separator+"test";
		String  name="names.txt";
		File fil2=new File(path1,name);
		//File(File parent, String child) 通过给定的文件位置File对象和给定的文件名称字符串创建新的 File实例。  
		String  path2="F:"+File.separator+"test";
		File filepath2=new File(path2);
		String  name2="names.txt";
		File file3=new File(filepath2,name2);
	}
}

注意：文件File类的对象创建以后，不会生成实际的文件。

实例方法：
  boolean         exists() 判断路径名表示的文件或目录是否存在。

  boolean         createNewFile() 创建新文件

  boolean         mkdirs() 创建新的文件夹

  boolean         delete() 删除文件/文件夹
        删除文件夹的时候要将该文件夹下的文件和子文件夹全部删除

  boolean         canRead() 判断文件是否可读

  boolean         canWrite() 判断文件是否可写

  boolean         isHidden() 判断文件是否为隐藏文件。

  boolean         isFile() 判断文件对象是否为普通文件。

  boolean         isDirectory() 判断文件对象是否为目录。

  String          getPath() 得到文件对象的路径名字符串。

  String          getName() 得到文件对象所表示的文件或目录的名称。

  String          getParent() 得到文件对象所表示的路径的父目录路径

  long             length() 得到文件对象所表示的文件的长度。

  long         lastModified() 得到文件对象所表示的文件上次修改的时间。

  String[]    list() 得到文件对象代表的文件夹中的所有文件和文件夹名称返回一个字符串数组

  File[]    listFiles() 得到文件对象代表的文件夹中的所有文件和文件夹的文件对象，返回一个文件对象数组

例如：

package com.wangxing.test1;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestFile3 {

	public static void main(String[] args)throws Exception {
		String  path="F:"+File.separator+"test";
		String  filepath="F:"+File.separator+"test"+File.separator+"names.txt";
		//创建保存文件夹的文件对象
		File file1=new File(path);
		//创建保存文件的文件对象
		File file2=new File(filepath);
		/*
		//创建文件夹
		//boolean	exists() 判断路径名表示的文件或目录是否存在。 
		System.out.println(file1.exists());
		if(!file1.exists()) {
			//boolean	mkdirs()  创建新的文件夹
			boolean dirfile=file1.mkdirs();
			if(dirfile) {
				if(!file2.exists()) {
					//boolean	createNewFile() 创建新文件
					file2.createNewFile();
				}
			}
		}else {
			//boolean	delete()  删除文件/文件夹
			//删除文件夹的时候要将该文件夹下的文件和子文件夹全部删除
			file1.delete();
		}
		*/
		//boolean	canRead() 判断文件是否可读
		System.out.println("canRead=="+file2.canRead());
		//boolean	canWrite() 判断文件是否可写 
		System.out.println("canWrite=="+file2.canWrite());
		//boolean	isHidden() 判断文件是否为隐藏文件。 
		System.out.println("isHidden=="+file2.isHidden());
		//boolean	isFile() 判断文件对象是否为普通文件。 
		System.out.println("isFile=="+file2.isFile());
		//boolean	isDirectory() 判断文件对象是否为目录。
		System.out.println("isDirectory=="+file1.isDirectory());
		//String	getPath() 得到文件对象的路径名字符串。 
		System.out.println("getPath=="+file2.getPath());
		//String	getName() 得到文件对象所表示的文件或目录的名称。 
		System.out.println("getName=="+file2.getName());
		//String	getParent() 得到文件对象所表示的路径的父目录路径 
		System.out.println("getParent=="+file2.getParent());
		//long	length() 得到文件对象所表示的文件的长度。 
		System.out.println("length=="+file2.length()+"字节");
		//long	lastModified() 得到文件对象所表示的文件上次修改的时间。 
		String time=new SimpleDateFormat("yyyy/MM/dd E HH:mm").format(new Date(file2.lastModified()));
		System.out.println("lastModified=="+time);
	}
}

运行结果：

在这里插入图片描述

package com.wangxing.test1;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestFile4 {

	public static void main(String[] args)throws Exception {
		/*
		//得到指定的文件夹下的文件和子文件夹名称
		String path="F:"+File.separator+"20200728"+File.separator+"java基础"+File.separator+"20200822java(19)";
		File file1=new File(path);
		String names[]=file1.list();
		for(String name:names) {
			System.out.println(name);
		}
		*/		
		//得到指定的文件夹下的文件和子文件夹对象
		String path="F:"+File.separator+"20200728"+File.separator+"java基础"+File.separator+"20200822java(19)";
		File file1=new File(path);
		File files[]=file1.listFiles();
		for(File f:files) {
			//得到子文件/子文件夹的名称
			String name=f.getName();
			//得到子文件/子文件夹的修改时间
			String time=new SimpleDateFormat("yyyy/MM/dd E HH:mm").format(new Date(f.lastModified()));
			//判断文件对象是否是一个文件
			String len="";
			String type="";
			if(f.isFile()) {
				len=f.length()+"字节";
				type=getType(name);
			}
			StringBuilder stringBuilder=new StringBuilder();
			stringBuilder.append(name+"\t");
			stringBuilder.append(time+"\t");
			stringBuilder.append(type+"\t");
			stringBuilder.append(len);
			System.out.println(stringBuilder.toString());
		}
	}
	/**
	 * 得到文件类型
	 * @param name
	 * @return
	 */
	public  static  String getType(String name) {
		String type="";
		String houz=name.substring(name.lastIndexOf("."));
		if(houz.equalsIgnoreCase(".mp4")) {
			type="MP4文件";
		}
		if(houz.equalsIgnoreCase(".docx")) {
			type="DOCX文档";
		}
		if(houz.equalsIgnoreCase(".chm")) {
			type="编译的html文件";
		}
		if(houz.equalsIgnoreCase(".java")) {
			type="java源文件";
		}
		if(houz.equalsIgnoreCase(".html")) {
			type="网页文件";
		}
		return type;
	}
}

运行结果：
在这里插入图片描述

二、IO流的划分与区别【字节流与字符流】

  IO流用来读写文件的内容
  流 —> 数据的流动轨迹。

  1. 按照数据的流动方向

  输入流—将数据读取到我们的处理程序中所形成的数据的流动轨迹就是输入流【读取数据】
  输出流—将我们程序处理以后的数据写出到某一个文件中所形成的数据的流动轨迹就是输出流【写出数据】

  2. 按照每一次读写数据的大小

  字节流—每一次读写一个字节【8位2进制】的数据量的流【字节流】
  由于所有的数据都可被换算成字节，所以字节流是可以读写任何类型的数据 【文本，视频，音频，图片】
  字符流—每一次读写一个字符【16位2进制】的数据量的流【字符流】
不能读写任何类型的数据，只能读写文本类型的数据。

IO流的综合划分
在这里插入图片描述

总结

在这里插入图片描述

三、常用的字节输入与字节输出流类

1.字节输出流OutputStream【顶级类】

public abstract class OutputStream
//不能被new
1.1、FileOutputStream类

定义：

public class FileOutputStream extends OutputStream

构造方法：

FileOutputStream(File file)通过File对象创建一个不可追加的字节输出流
FileOutputStream(File file, boolean append)通过File对象创建一个是否追加的字节输出流
FileOutputStream(String name)通过String 对象创建一个不可追加的字节输出流
FileOutputStream(String name, boolean append)通过String对象创建一个是否追加的字节输出流
例如：
package com.wangxing.test1;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestFileOutputStream1 {
	public static void main(String[] args) throws Exception{
		//FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。 
		String path1="F:"+File.separator+"test"+File.separator+"info.txt";
		File  file1=new File(path1);
		FileOutputStream  out1=new FileOutputStream(file1);
		OutputStream  out11=new FileOutputStream(file1);
		//FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
		FileOutputStream  out2=new FileOutputStream(file1,true);
		OutputStream  out22=new FileOutputStream(file1,true);
		//FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。  
		FileOutputStream  out3=new FileOutputStream(path1);
		OutputStream  out33=new FileOutputStream(path1);
		//FileOutputStream(String name, boolean append) 通过String对象创建一个是否追加的字节输出流
		FileOutputStream  out4=new FileOutputStream(path1,true);
		OutputStream  out44=new FileOutputStream(path1,true);
	}
}

实例方法：

voidwrite(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流
voidwrite(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流
voidwrite(int b) 将指定的字节写入此文件输出流
voidclose() 关闭此文件输出流并释放与此流相关联的任何系统资源

例如：

package com.wangxing.test1;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class TestFileOutputStream2 {

	public static void main(String[] args) throws Exception{
		//通过输出流 的写出方法将数据输出到文件中
		/*
		//void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
		//1准备需要写出的数据
		String info="hello,world";
		//2.创建字节输出流对象
		String path1="F:"+File.separator+"test"+File.separator+"info.txt";
		File file1=new File(path1); 
		FileOutputStream out1=new FileOutputStream(file1,true);
		//3.void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
		out1.write(info.getBytes());
		//4.关闭流
		out1.close();
		*/
		
		/*
		//void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 
		//1准备需要写出的数据
		String info="hello,world";
		//2.创建字节输出流对象
		String path1="F:"+File.separator+"test"+File.separator+"info.txt";
		File file1=new File(path1); 
		FileOutputStream out1=new FileOutputStream(file1,true);
		//3.void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 
		byte b[]=info.getBytes();
		out1.write(b,6,5);
		//4.关闭流
		out1.close();
		*/	
		//void	write(int b) 将指定的字节写入此文件输出流。 [执行一次只写出一个字节]
		//1准备需要写出的数据
		String info="hello,world";
		//2.创建字节输出流对象
		String path1="F:"+File.separator+"test"+File.separator+"info.txt";
		File file1=new File(path1); 
		FileOutputStream out1=new FileOutputStream(file1,true);
		//3.void	write(int b) 将指定的字节写入此文件输出流。 [执行一次只写出一个字节]
		byte bytearray[]=info.getBytes();
		for(byte b:bytearray) {
			out1.write(b);
		}
		//关闭流
		out1.close();
	}
}

运行结果：

在这里插入图片描述
  上面的字节输出流只能写出字节数组，不能直接写出基本数据类型的数据。

1.2 、DataOutputStream

定义：

public class DataOutputStream extends FilterOutputStream implements DataOutput

  数据输出流使应用程序以便携式方式将原始Java数据类型写入输出流

构造方法：

DataOutputStream(OutputStream out)创建一个新的数据输出流，以将数据写入指定的底层输出流

例如：

package com.wangxing.test2;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class TestDataOutputStream1 {
	public static void main(String[] args) throws Exception{
		//DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。 
		String path1="F:"+File.separator+"test"+File.separator+"data.txt";
		File  file=new File(path1);
		//FileOutputStream out=new FileOutputStream(file);
		OutputStream out=new FileOutputStream(file);
		DataOutputStream  dout=new DataOutputStream(out);
	}
}

实例方法：

voidwriteBoolean(boolean v) 将 boolean写入底层输出流作为1字节值
voidwriteByte(int v) 将 byte作为1字节值写入底层输出流
voidwriteChar(int v) 将 char写入底层输出流作为2字节值，高字节优先
voidwriteFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入该 int值基础输出流作为一个4字节的数量，高字节
voidwriteDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节
voidwriteInt(int v) 将底层输出流写入 int作为四字节，高位字节
voidwriteLong(long v) 将 long写入底层输出流，为8字节，高字节为首
voidwriteShort(int v) 将 short写入底层输出流作为两个字节，高字节优先
voidwriteUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流
voidflush() 刷新此数据输出流
voidclose() 关闭此输出流并释放与此流相关联的任何系统资源

例如：

package com.wangxing.test2;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class TestDataOutputStream2 {
	public static void main(String[] args) throws Exception{
		//DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。 
		String path1="F:"+File.separator+"test"+File.separator+"data.txt";
		File  file=new File(path1);
		//FileOutputStream out=new FileOutputStream(file);
		OutputStream out=new FileOutputStream(file,true);
		DataOutputStream  dout=new DataOutputStream(out);
		//void	writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。 
		dout.writeInt(1001);
		//void	writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
		dout.writeChar('\t');
		//void	writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。 
		dout.writeDouble(168.5);
		dout.writeChar('\t');
		//void	writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。 
		dout.writeBoolean(true);
		dout.writeChar('\t');
		//void	writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流。 
		dout.writeUTF("zhangsan");
		//void	flush() 刷新此数据输出流。 
		dout.flush();
		dout.close();
		out.close();
	}
}

运行结果：
在这里插入图片描述

2.字节输入流InputStream【顶级类】

定义：

public abstract class InputStream
//不能new
2.1、 FileInputStream
定义： 
public class FileInputStream extends InputStream

构造方法：

FileInputStream(File file)通过File对象创建一个字节输入流
FileInputStream(String name)通过String对象创建一个字节输入流

例如：

package com.wangxing.test1;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestInputStream1 {
	public static void main(String[] args) throws Exception{
		//FileInputStream(File file) 通过File对象创建一个字节输入流
		String path1="F:"+File.separator+"test"+File.separator+"info.txt";
		File file1=new File(path1);
		FileInputStream  in1=new FileInputStream(file1);
		InputStream  in11=new FileInputStream(file1);
		//FileInputStream(String name) 通过String对象创建一个字节输入流
		FileInputStream  in2=new FileInputStream(path1);
		InputStream  in22=new FileInputStream(path1);
	}
}

实例方法：

intread() 从该输入流读取一个字节的数据。 返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
intread(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。返回值:读取的总字节数， 如果到达文件末尾返回-1
voidclose() 关闭此文件输入流并释放与流相关联的任何系统资源

例如：

package com.wangxing.test1;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestInputStream1 {
	public static void main(String[] args) throws Exception{
		//读取info.txt中的数据值到我们的程序中
		
		/*
		//创建被读取数据的文件路径
		String path1="F:"+File.separator+"test"+File.separator+"info.txt";
		//根据文件路径创建对应的Fiel对象
		File file1=new File(path1);
		//创建字节输入流对象
		InputStream  in1=new FileInputStream(file1);
		//int	read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
		//返回值:读取的总字节数， 如果到达文件末尾返回-1
		byte  bytearray[]=new byte[(int)file1.length()];
		int len=in1.read(bytearray);
		//关闭流
		in1.close();
		String info=new String(bytearray,0,len);
		System.out.println(info);
		*/
		
		//创建被读取数据的文件路径
		String path1="F:"+File.separator+"test"+File.separator+"info.txt";
		//根据文件路径创建对应的Fiel对象
		File file1=new File(path1);
		//创建字节输入流对象
		InputStream  in1=new FileInputStream(file1);
		//int	read()从该输入流读取一个字节的数据。 
		//返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
		byte  bytearray[]=new byte[(int)file1.length()];
		//保存每一次读取的数据值
		int data=0;
		//数组下标
		int len=0;
		while((data=in1.read())!=-1) {
			bytearray[len]=(byte)data;
			len++;
		}
		//关闭流
		in1.close();
		String info=new String(bytearray,0,len);
		System.out.println(info);
	}
}

运行结果：
在这里插入图片描述

2.2、DataInputStream

定义：

public class DataInputStream extends FilterInputStream implements DataInput

构造方法：

DataInputStream(InputStream in)创建使用指定的底层InputStream的DataInputStream

例如：

package com.wangxing.test2;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestDataInputStream {
	public static void main(String[] args)throws Exception {
		//DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。
		String path1="F:"+File.separator+"test"+File.separator+"data.txt";
		File file=new File(path1);
		//FileInputStream  in=new FileInputStream(file);
		InputStream  in=new FileInputStream(file);
		DataInputStream  din=new DataInputStream(in);
	}

}

实例方法：

booleanreadBoolean()
bytereadByte()
charreadChar()
doublereadDouble()
floatreadFloat()
intreadInt()
longreadLong()
shortreadShort()
StringreadUTF()
voidclose()

例如：

package com.wangxing.test2;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestDataInputStream {
	public static void main(String[] args)throws Exception {
		//DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。
		String path1="F:"+File.separator+"test"+File.separator+"data.txt";
		File file=new File(path1);
		//FileInputStream  in=new FileInputStream(file);
		InputStream  in=new FileInputStream(file);
		DataInputStream  din=new DataInputStream(in);
		//int	readInt() 
		int intvalue=din.readInt();
		//char	readChar() 
		char op1=din.readChar();
		//double	readDouble() 
		double doublevalue=din.readDouble();
		char op2=din.readChar();
		//boolean	readBoolean() 
		boolean booleanvalue=din.readBoolean();
		char op3=din.readChar();
		//String	readUTF() 
		String string=din.readUTF();
		din.close();
		in.close();
		System.out.println(intvalue);
		System.out.println(doublevalue);
		System.out.println(booleanvalue);
		System.out.println(string);
	}
}

运行结果：
在这里插入图片描述

四、什么是序列化？如何实现序列化

  因为我们做操作的java对象可能需要在多台计算机之间传递。

  序列化 —> 将一个java对象转成2进制流数据过程。
  反序列化 —> 2进制流数据转换成一个java对象的过程。

如何实现序列化

1.为被序列化的java对象的生成类实现一个序列化接口【Serializable】 
public interface Serializable

  特殊 ==> 该接口中一个方法都没有

  类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化。 可序列化类的所有子类型都是可序列化的。

2. 通过java提供ObjectOutputStream类的writeObject(Object obj)
2.1、ObjectOutputStream

构造方法

ObjectOutputStream(OutputStream out)创建一个写入指定的OutputStream的ObjectOutputStream

实例方法

voidwriteObject(Object obj) 将指定的对象写入ObjectOutputStream

将java对象序列化到记事本文件。

package com.wangxing.test1;
import java.io.Serializable;
public class Student implements Serializable{
	public void  testMethod() {
		System.out.println("这是Student类的实例方法");
	}
}


package com.wangxing.test1;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class TestMain {

	public static void main(String[] args)throws Exception {
		Student  student=new Student();
		//ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。 
		String path1="F:"+File.separator+"test"+File.separator+"student.txt";
		File file=new File(path1);
		FileOutputStream  out=new FileOutputStream(file);
		ObjectOutputStream  objout=new ObjectOutputStream(out);
		objout.writeObject(student);
		objout.flush();
		objout.close();
		out.close();
	}
}

运行结果：
在这里插入图片描述

  将上面序列化到记事本文件中的java对象，反序列化回来成一个可使用的java对象。此时就需要ObjectInputStream类的Object readObject()方法读取对象。

2.2、ObjectInputStream

构造方法

ObjectInputStream(InputStream in)创建从指定的InputStream读取的ObjectInputStream

实例方法

ObjectreadObject() 从ObjectInputStream读取一个对象
package com.wangxing.test1;

import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class Test {

	public static void main(String[] args)throws Exception {
		//ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。 
		String path1="F:"+File.separator+"test"+File.separator+"student.txt";
		File file=new File(path1);
		FileInputStream  in=new FileInputStream(file);
		ObjectInputStream  objin=new ObjectInputStream(in);
		Object  obj=objin.readObject();
		objin.close();
		in.close();
		Student stu=(Student)obj;
		stu.testMethod();
	}
}

运行结果：
在这里插入图片描述

总结

在这里插入图片描述

五、常用的字符输入与字符输出流类

1、字符输出流

Write【顶级类】

public abstract class Writer
//不能new
1.1、FileWriter

  方便写字符文件

构造方法：

FileWriter(File file)给一个File对象构造一个FileWriter对象
FileWriter(File file, boolean append)给一个File对象构造一个是否允许追加FileWriter对象
FileWriter(String fileName)给一个String对象构造一个FileWriter对象
FileWriter(String fileName, boolean append)给一个String对象构造一个是否允许追加FileWriter对象

例如：

package com.wangxing.test1;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestWriter1 {
	public static void main(String[] args)throws Exception {
		//FileWriter(File file) 给一个File对象构造一个FileWriter对象。 
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		File file1=new File(path);
		FileWriter	out1=new FileWriter(file1);
		Writer	out11=new FileWriter(file1);
		//FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。 
		FileWriter	out2=new FileWriter(file1,true);
		Writer	out22=new FileWriter(file1,true);
		//FileWriter(String fileName) 给一个String对象构造一个FileWriter对象。
		FileWriter	out3=new FileWriter(path);
		Writer	out33=new FileWriter(path);
		//FileWriter(String fileName, boolean append)  给一个String对象构造一个是否允许追加FileWriter对象。
		FileWriter	out4=new FileWriter(path,true);
		Writer	out44=new FileWriter(path,true);
	}
}

实例方法：

voidwrite(char[] cbuf) 写入一个字符数组
voidwrite(char[] cbuf, int off, int len) 写入字符数组的一部分
voidwrite(int c) 写一个字符
voidwrite(String str) 写一个字符串
voidwrite(String str, int off, int len) 写一个字符串的一部分
voidclose() 关闭流，先刷新
voidflush() 刷新流

例如：

package com.wangxing.test1;

import java.io.File;
import java.io.FileWriter;
import java.io.Writer;

public class TestWriter2 {

	public static void main(String[] args)throws Exception {
		//创建字符输出流对象
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		File file1=new File(path);
		FileWriter	out1=new FileWriter(file1);
		//准备需要写出的数据
		String info="hello,world";
		/*
		//void	write(char[] cbuf) 写入一个字符数组。 
		char cbuf[]=info.toCharArray();
		out1.write(cbuf);
		*/
		
		/*
		//void	write(char[] cbuf, int off, int len) 写入字符数组的一部分。 
		char cbuf[]=info.toCharArray();
		out1.write(cbuf,6,5);
		*/
		
		/*
		//void	write(int c) 写一个字符 
		char cbuf[]=info.toCharArray();
		for(char c:cbuf) {
			out1.write(c);
		}
		*/
		
		/*
		//void	write(String str) 写一个字符串 
		out1.write(info);
		*/
		
		//void	write(String str, int off, int len) 写一个字符串的一部分。
		out1.write(info,6,5);
		out1.flush();
		out1.close();
	}
}

运行结果：

在这里插入图片描述

1.2、BufferedWriter

  将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入

 public class BufferedWriter

构造方法：

BufferedWriter(Writer out)创建使用默认大小的输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out, int sz)创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区

例如：

package com.wangxing.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
public class TestBufferedWriter1 {
	public static void main(String[] args)throws Exception {
		//BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。 
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		File  file=new File(path);
		FileWriter  out=new FileWriter(file); //底层字符输出流
		BufferedWriter  bout1=new BufferedWriter(out);//高级字符输出流
		//BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。 
		BufferedWriter  bout2=new BufferedWriter(out,100);//高级字符输出流
	}
}

实例方法：

voidclose() 关闭流，先刷新
voidflush() 刷新流
voidnewLine() 写一行行分隔符
voidwrite(char[] cbuf, int off, int len) 写入字符数组的一部分
voidwrite(int c) 写一个字符
voidwrite(String s, int off, int len) 写一个字符串的一部分
例如：
package com.wangxing.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
public class TestBufferedWriter2 {
	public static void main(String[] args)throws Exception {
		//创建字符输出流对象
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		File  file=new File(path);
		FileWriter  out=new FileWriter(file); //底层字符输出流
		BufferedWriter  bout1=new BufferedWriter(out);//高级字符输出流
		//准备输出的数据
		String  info1="hello,world";
		String  info2="hello,world";
		/*
		//void	write(char[] cbuf, int off, int len) 写入字符数组的一部分。 
		char  array[]=info.toCharArray();
		bout1.write(array, 0, 5);
		*/
		/*
		//void	write(int c) 写一个字符 
		char  array[]=info.toCharArray();
		for(char c:array) {
			bout1.write(c);
		}
		*/
		/*
		//void	write(String s, int off, int len) 写一个字符串的一部分。 
		bout1.write(info, 0, info.length());
		*/
		
		bout1.write(info1, 0, info1.length());
		//void	newLine() 写一行行分隔符。 
		bout1.newLine();
		bout1.write(info2, 0, info2.length());
		bout1.flush();
		bout1.close();
		out.close();
	}
}

运行结果：
在这里插入图片描述

1.3、OutputStreamWriter

  将字节输出流转换成字符输出流

public class OutputStreamWriter

构造方法

  OutputStreamWriter(OutputStream out)  将字节输出流转换成字符输出流

实例方法：

voidwrite(char[] cbuf) 写入一个字符数组
voidwrite(char[] cbuf, int off, int len) 写入字符数组的一部分
voidwrite(int c) 写一个字符
voidwrite(String str) 写一个字符串
voidwrite(String str, int off, int len) 写一个字符串的一部分
voidclose() 关闭流，先刷新
voidflush() 刷新流

例如：

package com.wangxing.test3;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class TestOutputStreamWriter {
	public static void main(String[] args)throws Exception {
		String info="hello,world";
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
        FileOutputStream  out=new FileOutputStream(path);
        //我们是可以通过FileOutputStream这个字节输出流将数据保存到文件中，
        //但是需要将被保存的文件转换成字节数组才可以。
        //如果我们不想将将被保存的文件转换成字节数组写出，这时我们可以通过OutputStreamWriter，
        //将字节输出流转换成字符输出流，直接写出String数据
        OutputStreamWriter  owtiter=new OutputStreamWriter(out);
        owtiter.write(info);
        owtiter.flush();
        owtiter.close();
        out.close();
	}
}

运行结果：

在这里插入图片描述

2、字符输入流

Reader【顶级类】

public abstract class Reader
//不能new
2.1、 FileReader

  读取字符文件的

构造方法：

FileReader(File file)创建一个新的 FileReader ，给出 File读取
FileReader(String fileName)创建一个新的 FileReader ，给定要读取的文件的名称
例如：
package com.wangxing.test1;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;

public class TestFileReader1 {

	public static void main(String[] args)throws Exception {
		//FileReader(File file) 创建一个新的 FileReader ，给出 File读取。 
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		File file1=new File(path);
		FileReader  in1=new FileReader(file1);
		Reader  in11=new FileReader(file1);
		//FileReader(String fileName)创建一个新的 FileReader ，给定要读取的文件的名称。 
		FileReader  in2=new FileReader(path);
		Reader  in22=new FileReader(path);
	}
}

实例方法：

intread() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
intread(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
voidclose() 关闭流并释放与之相关联的任何系统资源

例如：

package com.wangxing.test1;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestFileReader2 {
	public static void main(String[] args)throws Exception {
		//创建输入流对象
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		File file1=new File(path);
		FileReader  in1=new FileReader(file1);
		/*
		//int	read(char[] cbuf) 将字符读入数组。 返回总字符数，如果到达文件末尾返回-1
		char cbuf[]=new char[(int)file1.length()];
		int len=in1.read(cbuf);
		System.out.println("len=="+len);
		in1.close();
		String info=new String(cbuf,0,len);
		System.out.println(info);
		*/
		
		//int	read() 读一个字符 
		char cbuf[]=new char[(int)file1.length()];
		//保存每一次读取的字符数据
		int  data=0;
		//定义数据访问下标
		int len=0;
		while((data=in1.read())!=-1) {
			cbuf[len]=(char)data;
			len++;
		}
		in1.close();
		String info=new String(cbuf,0,len);
		System.out.println(info);
	}
}

运行结果：
在这里插入图片描述

2.2、BufferedReader

  从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。

 public class BufferedReader

构造方法：

BufferedReader(Reader in)创建使用默认大小的输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)创建使用指定大小的输入缓冲区的缓冲字符输入流

例如：

package com.wangxing.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class TestBufferedReader1 {
	public static void main(String[] args)throws Exception {
		//BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。 
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		File  file=new File(path);
		FileReader in=new FileReader(file);
		BufferedReader  bin1=new BufferedReader(in);
		//BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。 
		BufferedReader  bin2=new BufferedReader(in,100);
	}
}

实例方法：

intread() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
intread(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
voidclose() 关闭流并释放与之相关联的任何系统资源
StringreadLine() 读一行文字

例如：

package com.wangxing.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class TestBufferedReader2 {
	public static void main(String[] args)throws Exception {
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		File  file=new File(path);
		FileReader in=new FileReader(file);
		BufferedReader  bin1=new BufferedReader(in);
		//String	readLine() 读一行文字。 
		//定义保存每一行数据的字符串变量
		String line=null;
		while((line=bin1.readLine())!=null) {
			System.out.println(line);
		}
		bin1.close();
		in.close();
	}
}

运行结果：
在这里插入图片描述
  使用BufferedReader的readLine方法来代替Scanner类的nextLine方法从控制台不去数据

例如：

package com.wangxing.test2;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class TestBufferedReader3 {
	public static void main(String[] args)throws Exception {
		BufferedReader  bin1=new BufferedReader(new InputStreamReader(System.in));
	    System.out.println("请输入姓名:");
	    String name=bin1.readLine();
	    System.out.println("你输入的姓名是==="+name);
	}
}

运行结果：

在这里插入图片描述

2.3、InputStreamReader

  将字节输入流转换成字符输入流

public class InputStreamReader

构造方法：

InputStreamReader(InputStream in)将字节输入流转换成字符输入流
实例方法：
intread() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
––
intread(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
voidclose() 关闭流并释放与之相关联的任何系统资源

例如

package com.wangxing.test3;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class TestInputStreamReader {
	public static void main(String[] args)throws Exception {
		String  path="F:"+File.separator+"test"+File.separator+"msg.txt";
		FileInputStream  in=new FileInputStream(path);
		InputStreamReader  ireader=new InputStreamReader(in);
		BufferedReader bin=new BufferedReader(ireader);
		String line=null;
		while((line=bin.readLine())!=null) {
			System.out.println(line);
		}
		bin.close();
		ireader.close();
		in.close();
	}
}

运行结果：

在这里插入图片描述

总结

  输入输出的操作步骤:
    1.创建文件对象【File对象】，指定输入输出的位置
    2.创建输入输出流对象
      1.文本选字符流，其他的选字节
      2.读取选输入，保存选输出
    3.调用read()/write()方法
    4.关闭流

  以“ InputStream”结尾的流是字节输入流
  以“ OutputStream ”结尾的流是字节输出流
  以“ Reader ”结尾的流是字符输入流
  以“ Writer ”结尾的流是字符输出流
在这里插入图片描述

夏至青柠
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA输入和输出处理（IO流）
m0_46620354的博客
08-26 210
IO从程序的角度出发：程序的读和写。 文件：相关记录或放在一起的数据的集合。文件一般存储在硬盘中。 Java程序访问文件属性通过java.io.File 类。 File类访问文件属性：导入File类>>>>创建文件对象：File file = new File( String pathname（里面填你要访问的文件的路径"c:\\test .txt" 或 "c:/test .txt"） );>>>>通过文件对象的方法操作文件或目录的属性 （路径、权限、日
java 对象输出流_java基础49 IO流技术（对象输入流/对象输出流）
weixin_35911307的博客
02-13 442
1、对象输入输出流对象注意作用是用于写对象信息与读取对象信息1.对象输出流：ObjectOutputStream2.对象输入流：ObjectInputStream2、对象输入输出流的步骤ObjectInputStreamObjectOutputStream1.找到目标文件2.建立数据输入通道3.创建输入流对象4.读取对象信息(读取硬盘上的对象信息)5.关闭资源1.找到目标文件2.建立数据输出通道3...
java中IO对list的读写操作
城之于域的博客
08-23 234
1.自定义类实现serializable接口 package day20; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java...
Java IO流之对象输入输出流
weixin_52629592的博客
04-08 668
IO 对象输入输出流 什么是对象? 对象指的就是java运行过程中产生的对象 如: new Date() , new String() 对象输入输出流 : 主要的作用是用于写入对象信息与读取对象信息。 对象信息 一旦写到文件上那么对象的信息就可以做到持久化了 对象的输出流： ObjectOutputStream 对象的输入流: ObjectInputStream 对象序列化 对象的寿命通常随着生成该对象的程序的终止而终止。 有时候，可.
Java后端接口返回视频流，使用video组件播放视频，实现分段下载
m0_67401134的博客
09-07 5798
所以实现视频断点播放的大概思路为，先识别http请求头是否携带range请求头，如果携带则表示请求需要进行断点下载，识别出断点的位置后使用随机读取文件类RandomAccessFile进行一定范围的读写，之后返回设置Content-Range请求头表示返回数据的范围，并设置http状态码为206表示断点传输。小视频问题不大，视频大的话会卡顿很久，查看请求发现会先请求下载完整视频后开始播放。视频文件保存在不为人知的地方，总之前端不能直接访问的位置，需要通过后端接口取出来再返回给前端。如果后端直接这样子写。
Java工程师成神之路（基础篇）.zip
08-15
9. **IO流**：理解输入输出流的分类和工作原理，包括字节流和字符流，以及缓冲流、对象序列化等高级主题。 10. **多线程**：了解Java中的线程概念，学习如何创建线程，实现Runnable接口或继承Thread类，以及线程...
Java技术教程.基础篇
01-12
9. **输入/输出流**：Java的IO流系统用于读写数据，包括文件操作、字符流和字节流。学会使用InputStream、OutputStream、Reader、Writer等类进行数据传输。 10. **集合框架**：Java集合框架包括接口（如List、Set和...
java语言程序设计基础进阶篇代码
04-21
- **IO流**：掌握输入输出流的概念，使用FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等进行文件操作。 - **多线程**：理解线程的概念，学习Thread类和Runnable接口，实现并发编程。 - **...
java基础篇，开发指南
05-14
8. **输入输出流**：Java的IO流系统用于读写文件和网络通信，包括字节流、字符流、缓冲流和对象序列化等概念。 9. **集合框架**：Java集合框架包括List、Set、Queue和Map接口，以及ArrayList、LinkedList、HashSet...
【一篇足矣，313页最全合集】java后端开发学习路线+基础知识+计算机基础+八股文+大厂面经+程序员简历制作
05-08
4. **IO与NIO**：理解Java输入输出（IO）流，以及非阻塞IO（NIO）和异步IO（AIO）的概念，学习如何实现高效的数据读写。 5. **网络编程**：学习Socket编程，了解TCP与UDP的区别，以及如何通过Java进行网络通信。 6...
java实现video标签视频流播放
最新发布
lvhong1234的博客
03-03 17万+
java实现分片文件video标签播放
java respose输出mp4文件流_通过OutputStream对文件又流的方式输出
weixin_33601402的博客
02-25 752
import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import javax.servlet.ServletExcepti...
JAVA如何实现视频在线播放（MP4文件在线播放）
RE_Z002的博客
08-04 9万+
JAVA如何实现视频在线播放（MP4文件在线播放），这里只支持对MP4格式视频的播放，其他格式的需要大家进行转换后才可进行播放，格式转换可以使用格式工具进行转换。不需要web端进行操作，即可直接进行播放，话不多说，直接上代码！经过个人实际确认，功能确已实现，希望对大家有用。...
Java实现文件写入——IO流（输入输出流详解）
张博在读
09-09 14万+
输入输出的重要性：      输入和输出功能是Java对程序处理数据能力的提高，Java以流的形式处理数据。流是一组有序的数据序列，根据操作的类型，分为输入流和输出流。      程序从输入流读取数据，向输出流写入数据。Java是面向对象的程序语言，每一个数据流都是一个对象，它们提供了各种支持“...
Java(2)-Java IO输入输出流
热门推荐
黄规速博客:学如逆水行舟，不进则退
04-01 20万+
最详细的I/O介绍 Java中I/O操作主要是指使用Java进行输入，输出操作.Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 Java.io是大多数面向数据流的输入/输出类的主要软件......
【Java基础】Java输入输出（IO）流
wang_qiu_hao的博客
07-27 1399
在Java中所有数据都是使用流读写的。流是一组有序的数据序列，将数据从一个地方带到另一个地方。根据数据流向的不同，可以分为输入（Input）流和输出（Output）流两种。下面详细介绍什么是输入流和输出流，以及Java中流的类型及每种类型的相关类。1.什么是输入/输出流Java程序通过流来完成输入/输出，所有的输入/输出以流的形式处理。因此要了解I/O系统，首先要理解输入/输出流的概念。（一）“字节”的定义（二）“字符”的定义（三）“字节”与“字符”的区别httpshttps。...............
JAVA输入/输出流详细讲解
weixin_45536242的博客
07-09 1万+
应用程序经常需要访问文件和目录，读取文件信息或写入信息到文件，即从外界输入数据或者向外界传输数据，这些数据可以保存在磁盘文件、内存或其他程序中。在Java中，对这些数据的操作是通过I/O技术来实现的。所谓I/O技术，就是数据的输入（Input）、输出（Output）技术。本章将对Java的 I/O系统进行讲解，包括I/O的体系结构、流的概念、字节流、处理字节流的基本类InputStream和OutputStream、字符流、处理字符流的基本类Reader和Writer、文件管理、序列化和反序列化等。12.1
java基础_笔记3（文件处理）
m0_64589497的博客
09-13 147
流的分类往内存中去的叫做输入流INPUT往磁盘中去的叫做输出流ouput一次读取一个字节的叫字节流一次读取一个字符的叫字符流四大家族InputStream 字节输入流OuputStream字节输出流Reader 字符输入流Writer 字符输出流以上的类都是抽象类所有的流开启之后都是可关闭的，存在一个close方法。
JAVA实现IO流之日记本（记事本）
遇安的博客
04-19 6506
要求：编写一个模拟日记本的程序，通过在控制台输入指令，实现在本地新建文件，打开日记本和修改日记本等功能。 指令1代表“新建日记本”，可以从控制台获取用户输入的日记内容 指令2代表“打开日记本”，读取指定路径的TXT文件的内容并输出到控制台 指令3代表“修改日记本”，修改日记本中原有的内容 指令4代表保存 指令5代表退出 import java.io.*; import java.util.Scanner; public class IO_日记本 { /** * 模拟日记本程序
Java程序设计：声明数组与内存分配
- **Java IO**：掌握输入/输出流，缓冲区，字符编码等操作。 - **JDBC**：学习如何与数据库交互，执行SQL语句，处理结果集。 3. **如何学习JavaSE技术**：强调基础的重要性，学会查阅官方文档，提高解决问题的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值