IO流复习总结（二） IO流、字节流

最新推荐文章于 2022-04-03 10:37:00 发布

钦拆大仁

最新推荐文章于 2022-04-03 10:37:00 发布

阅读量286

点赞数

分类专栏： # IO流文章标签： IO java基础

本文链接：https://blog.csdn.net/qq_36154832/article/details/88795920

版权

IO流专栏收录该内容

6 篇文章 0 订阅

订阅专栏

IO流

File类是用来描述文件或文件夹的抽象形式，它具备操作文件的很多功能。但是它不能操作文件的内容。操作文件内容，就要用到IO流的知识。我们读文件还是写文件，都是实现数据在设备之间传输，数据的传输可以看做水流一样。，因此叫IO流。

io流的分类

1）从数据流向分为输入流和输出流：

输入流：读取数据，从硬盘读取数据到内存中

输出流：写出数据，把内存中的数据写出到硬盘中

2）按数据类型分为字节流和字符流：

计算机中的一切数据都是字节数据。

字符数据：人类识别的文字符号。本质也是以字节形式存储。只不过软件可以按照字符的规则把字节变成字符给我们看。

字节输入流：InputStream 子类:XxxInputStream

字节输出流：OutputStream 子类:XxxOutputStream

字符输入流：Reader 子类：XxxReader

字符输出流：Writer 子类：XxxWriter

FileOutputStream

构造函数：FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。

FileOutputStream的三种写出：public void write(int b) 写出一个字节,要写的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。public void write(byte[] b) 写出一个字节数组。public void write(byte[] b,int off,int len) 写出字节数组b中，从off开始，共len个字节。

append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处：FileOutputStream(File file, boolean append)
FileOutputStream(String name, boolean append) 。

FileInputStream

构造函数：FileInputStream(File file) 。FileInputStream(String name)

读取功能：int read() 读取并返回下一个字节。字节输入流的使用步骤：A：创建输入流，关联源文件； B：读取数据；C：释放资源。
输入流在关联源文件时，如果源文件不存在，不会创建，而是抛出异常！ java.io.FileNotFoundException: fis.txt (系统找不到指定的文件。)

输出输入缓冲流

BufferedOutputStream

构造方法摘要：BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流； BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。缓冲流底层的读写用的还是普通的字节流，只不过用普通字节流读写的数据，缓存取来，然后以后就不必再去硬盘读取。

BufferedInputStream

构造函数：BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。 BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

四种复制时间对比

*    1）普通字节流，一次读一个字节
*    2）普通字节流，一次读多个字节
*    3）缓冲字节流，一次读一个字节
*    4）缓冲字节流，一次读多个字节

public static void main(String[] args) throws IOException {
	long begin = System.currentTimeMillis();
	method_01();
	long end = System.currentTimeMillis();
	System.out.println("共耗时" + (end - begin) + "毫秒");
}

// 4）缓冲字节流，一次读多个字节	共耗时29毫秒
public static void method_04() throws IOException {
	// 创建输入流，关联源文件
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\test\\制服诱惑.avi"));
	// 创建输出流，关联目标文件
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\zfyh.avi"));
	// 读写数据
	byte[] buf = new byte[1024];
	int len = 0;
	while((len = bis.read(buf)) != -1){
		bos.write(buf, 0, len);
	}
	// 释放资源
	bis.close();
	bos.close();
}

// 3）缓冲字节流，一次读一个字节 共耗时437毫秒
public static void method_03() throws IOException {
	// 创建输入流，关联源文件
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\test\\制服诱惑.avi"));
	// 创建输出流，关联目标文件
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\zfyh.avi"));
	// 读写数据
	int b = 0;
	while ((b = bis.read()) != -1) {
		bos.write(b);
	}
	// 释放资源
	bis.close();
	bos.close();
}

// 2）普通字节流，一次读多个字节 共耗时74毫秒
public static void method_02() throws IOException {
	// 创建输入流，关联源文件
	FileInputStream fis = new FileInputStream("D:\\test\\制服诱惑.avi");
	// 创建输出流，关联目标文件
	FileOutputStream fos = new FileOutputStream("E:\\zfyh.avi");
	// 读写数据
	byte[] buf = new byte[1024];
	int len = 0;
	while ((len = fis.read(buf)) != -1) {
		fos.write(buf, 0, len);
	}
	// 释放资源
	fis.close();
	fos.close();
}

// 1）普通字节流，一次读一个字节 共耗时39995毫秒
public static void method_01() throws IOException {
	// 创建输入流，关联源文件
	FileInputStream fis = new FileInputStream("D:\\test\\制服诱惑.avi");
	// 创建输出流，关联目标文件
	FileOutputStream fos = new FileOutputStream("E:\\zfyh.avi");
	// 读写数据
	int b = 0;
	while ((b = fis.read()) != -1) {
		fos.write(b);
	}
	// 释放资源
	fis.close();
	fos.close();
}

小练习

扫描D:\\test下所有的.docx文件，复制到一个指定文件夹:D:\\test1

我们首先可以扫描这个目录下的所有文件，找到其中的docx文件。我们找到后，直接复制就OK了！
   * 思路：
   *    A：封装目标文件夹的File对象
   *    B：获取目标文件夹下的所有儿子
   *    C：循环遍历，取出每个儿子
   *    D：判断是否是文件夹
   *        是：回到步骤B
   *        否：判断是否是docx文件
   *            是：直接复制
   *            否：不管
   *    上面的流程中，B到D的步骤是重复的，封装成递归的函数。
   * 问题1：指定文件夹不能在要扫描的文件夹下。
   * 问题2：如果有同名文件，就会导致文件的覆盖，会丢失文件。
   *        在原来名字的基础上，多加一个唯一的标记

public static void main(String[] args) throws IOException {
	// A：封装目标文件夹的File对象
	File dest_folder = new File("D:\\test");
	// 调用递归扫描的函数
	scanFolders(dest_folder);
}
// 递归扫描并复制的函数
public static void scanFolders(File dest_folder) throws IOException {
	// B：获取目标文件夹下的所有儿子
	File[] files = dest_folder.listFiles();
	// C：循环遍历，取出每个儿子
	for( File file : files){
		// D：判断是否是文件夹
		if( file.isDirectory()){
			// 是：回到步骤B
			scanFolders(file);
		}else{
			// 否：判断是否是docx文件
			if( file.getName().endsWith(".docx")){
				long time = System.currentTimeMillis();
				// 是docx，复制文件
				System.out.println(file);
				// 源文件：file
				// 目标文件：是一个在指定文件夹(D:\\lesson\\笔记)下与源文件同名的文件
				File dest_file = new File("D:\\test1",time + "_" +file.getName());
				// 复制文件
				copyFile(file,dest_file);
			}
		}
	}
}
/*
 * 抽取一个复制文件的方法。
 * 	明确返回值类型：void
 * 	明确参数列表：File src_file, File dest_file
 */
public static void copyFile(File src_file, File dest_file) throws IOException{
	// 创建输入流，关联源文件
	FileInputStream fis = new FileInputStream(src_file);
	// 创建输出流，关联目标文件
	FileOutputStream fos = new FileOutputStream(dest_file);
	// 读写数据
	byte[] buf = new byte[1024 * 10];
	int len = 0;
	while((len = fis.read(buf)) != -1){
		fos.write(buf, 0, len);
	}
	// 释放资源
	fis.close();
	fos.close();
}
public static void copyFile(String src_file, String dest_file) throws IOException{
	// 调用上面的方法。
	copyFile(new File(src_file),new File(dest_file));
}

切割合并文件

需求：把D:\\test\\制服诱惑.avi切割成碎片文件
* 分析：
*    数据切割：可以按大小切。可以按数量。我们今天按照大小切。把这个视频按照：2M一个切。
*    数据源：一个完整的AVI文件。用输入流关联这个文件。读取数据。用FileInputStream。每次读2M
*    目的地：是多个碎片文件。每次我们读2M，然后把这2M写到一个碎片，下次换另一个文件。文件的名称由我们定义。
*            我们可以用递增的数字，来作为文件的名称。
* 思路：
*    A：创建一个输入流，关联源文件
*    B：循环读取，每次2M数据
*    C：创建输出流，关联一个碎片文件
*    D：把2M数据写出到输出流
*    E：关闭输出流
*    F：循环结束，关闭输入流
*
* 合并文件：
* 分析：
*    数据源：多个碎片文件。我们要用多个输入流，分别关联这些文件，然后依次读取，把读取到的数据写到输出流
*    目的地：一个avi文件。创建输出流关联这个文件。FileOutputStream。
* 首先，我们先写把一个碎片写到目的地。

public static void main(String[] args) throws IOException {
//	cutFile();
	mergeFile();
}
// 合并文件
public static void mergeFile() throws IOException {
	// 创建输出流，关联目标文件
	FileOutputStream fos = new FileOutputStream("E:\\zfyh.avi");
	// 循环读取6个碎片
	for( int i = 1; i <= 6; i++){
		// 创建输入流，关联源文件
		FileInputStream fis = new FileInputStream("abc\\"+i+".avi");
		// 读写数据
		byte[] buf = new byte[1024];
		int len = 0;
		while((len = fis.read(buf)) != -1){
			fos.write(buf, 0, len);
		}
		// 释放资源
		fis.close();
	}
	fos.close();
}
// 演示：文件的切割
public static void cutFile() throws IOException {
	// A：创建一个输入流，关联源文件
	FileInputStream fis = new FileInputStream("D:\\test\\制服诱惑.avi");
	// 记录碎片个数
	int count = 1;
	// B：循环读取，每次2M数据
	byte[] buf = new byte[1024 * 1024 * 2];
	int len = 0;
	while((len = fis.read(buf)) != -1){
		// C：创建输出流，关联一个碎片文件
		FileOutputStream fos = new FileOutputStream("abc\\" + (count++) + ".avi");
		// D：把2M数据写出到输出流
		fos.write(buf, 0, len);
		// E：关闭输出流
		fos.close();
	}
	// F：循环结束，关闭输入流
	fis.close();
}