Java IO流

IO流

1. IO流

1.1 IO流概述

IO
	==> input 输入 output 输出
	参照物是当前程序占用的内存空间。
	input输入:
		案例 从文件中读取数据到内存 输入
	output输出:
		案例 从内存保存数据到文件 输出

IO流
	1. 可以解决数据在文件，数据库保存和读取问题
	2. 网络数据传输，TCP UDP 网络传输协议都是基于IO流实现。

1.2 IO流分类

按照数据处理单位划分
	字节流 【重点】
		当前资源内容在IO流中按照字节方式进行传输。非常常见 
	字符流 
		首先按照字节方式读取或者传输数据，在按照当前计算机字符环境翻译对应的字节数据。
		适用范围较小。一般用于可以使用记事本打开的可视化文本文件。一般针对.txt 程序文件
按照数据流向划分
	输入流
	输出流

字节输入流
	InputStream 字节输入流基类
	--| FileInputStream 文件操作字节输入流 
字节输出流
	OutputStream 字节输出流基类
	--| FileOutputStream 文件操作字节输出流 
字符输入流
	Reader 字符输入流基类
	--| FileReader 文件操作字符输入流 
字符输出流
	Writer 字符输出流基类
	--| FileWriter 文件操作字符输出流 

两个核心方法:
	read 读取数据
	write 写入数据

思想:
	文件操作涉及到针对IO流资源处理问题和管道思想。

1.3 文件操作字节输入流

构造方法:
	FileInputStream(String fileName);
		根据用户指定的文件路径，创建对应FileInputStream字节输入流对象
	FileInputStream(File file);	
		根据用户指定的File类对象，创建对应FileInputStream字节输入流对象

成员方法:
	int read();
		从文件中读取一个字节数据返回，返回值类型为int类型，但是实际有效数据空间为当前int类型的低8位
	int read(byte[] buffer);【重点方法】
		从文件中读取数据保存到byte类型的缓冲数组中，返回值类型为int类型，是读取到的字节个数。
	int read(byte[] buffer, int offset, int count);	
		从文件中读取数据保存到byte类型的缓冲数组中，要求从offset位置开始存储数据，最大允许存储个位为count，
		返回值类型是真实读取到的字节个数。
	tips:
		以上所有read方法，如果读取到文件末尾，返回值为-1 EOF End Of File

package com.qfedu.a_io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
 * 文件操作字节输入流读取文件的过程
 * 	1. 明确操作文件
 * 		a. 当前指定文件的路径，相对路径，绝对路径
 * 		b. 根据当前指定文件路径，创建一个File类对象
 *	2. 创建对象当前文件的FileInputStream 文件操作字节输入流对象，打开管道
 *	3. 使用read方法，从文件中读取数据到当前程序
 *	4. 关闭资源【重点】
 */
public class Demo1 {
	public static void main(String[] args) throws IOException {
		// 带缓冲 81
		// readTest2();
		// 无缓冲 64396
		// readTest1();
        // 使用缓冲数组效率明显高于未使用缓冲
	}

	// 使用数组作为缓冲操作
	public static void readTest2() throws FileNotFoundException, IOException {
		// 获取当前方法开始的毫秒数时间戳
		long start = System.currentTimeMillis();
		// 1. 明确操作文件
		String filePath = "F:/aaa/1.txt";

		// 2. 创建对象当前文件的FileInputStream 文件操作字节输入流对象，打开管道
		FileInputStream fis = new FileInputStream(filePath);

		// 3. 使用read方法，从文件中读取数据到当前程序
		// 准备一个byte类型缓冲数组，一般建议当前缓冲数组为1KB 2KB 4KB[推荐] 8KB[推荐] 16KB[推荐]
		byte[] buffer = new byte[1024];
		int length = -1;

		while ((length = fis.read(buffer)) != -1) {
			/*
			 * String(char[] arr, int offset, int length); String(byte[] arr, int offset,
			 * int length);
			 */
			// System.out.println(new String(buffer, 0, length));
		}

		// 4. 关闭资源
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("Time : " + (end - start));
	}

	// 不是数组缓冲
	public static void readTest1() throws FileNotFoundException, IOException {
		// 获取当前方法开始的毫秒数时间戳
		long start = System.currentTimeMillis();
		// 1. 明确操作文件
		String filePath = "F:/aaa/1.txt";

		// 2. 创建对象当前文件的FileInputStream 文件操作字节输入流对象，打开管道
		FileInputStream fis = new FileInputStream(filePath);

		// 3. 使用read方法，从文件中读取数据到当前程序
		int content = -1;

		while ((content = fis.read()) != -1) {
			// System.out.println((char) content);
		}

		// 4. 关闭资源
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("Time : " + (end - start));
	}
}

1.4 文件操作字节输出流

构造方法:
	FileOutputStream(String filePath);
		根据用户指定的文件路径(相对路径/绝对路径)，创建对应的FileOutputStream类对象
	FileOutputStream(File file);
		根据用户指定的File对象，创建对应的FileOutputStream类对象
	FileOutputStream(String filePath, boolean append);
		根据用户指定的文件路径(相对路径/绝对路径)，创建对应的FileOutputStream类对象。append对应数据为
		true，表示追加写
	FileOutputStream(File file, boolean append);
		根据用户指定的File对象，创建对应的FileOutputStream类对象。append对应数据为true，表示追加写
	
	补充说明 tips:
		1. FileOutputStream构造方法拥有创建文件的能力，如果当前指定的路径合法，并且有可写入权限，当前文件不
		存在的情况下，可以进行创建操作.
		2. FileOutputStream默认写入数据的方式【删除写/清空写】。首先删除当文件的所有内容，重写写入数据。如
		果要求完成追加写操作。需要在构造方法中，加入一个参数boolean append

成员方法:
	void write(int b);
		写入一个字节数据到文件中
	void write(byte[] arr);
		写入一个字节数组数据到文件中
	void write(byte[] arr, int offset, int length);	
		写入一个字节数组数组到文件中，要求从指定位置offset开始，计数长度为length

package com.qfedu.a_io;

import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 文件操作字节输出流演示 FileOutputStream
 * 		1. 明确文件
 * 		2. 创建FileOutputStream对象，打开管道
 * 		3. 写入数据
 * 		4. 关闭资源
 */
public class Demo2 {
	public static void main(String[] args) throws IOException {
		// 1. 明确文件
		String filePath = "F:/aaa/你大爷的.txt";
		
		// 2. 创建FileOutputStream对象，打开管道
		FileOutputStream fos = new FileOutputStream(filePath, true);
		
		// 3. 写入数据到文件中
		fos.write('1');
		fos.write('2');
		fos.write('3');
		
		// byte[] getBytes(); 将字符串直接转为byte数组
		fos.write("\n中午吃炸酱面\n".getBytes());
		fos.write("ABCDEFGHIJKLMN".getBytes(), 2, 8);
		
		// 4. 关闭资源
		fos.close();
	}
}

1.5 文件操作字符输入流

构造方法:
	FileReader(String filePath);
		根据用户指定的String类型文件路径(相对路径/绝对路径)，创建FileReader字符输入流对象
	FileReader(File file);
		根据用户指定的File类对象，创建FileReader字符输入流对象
	
成员方法:
	int read();
		从指定文件中读取一个字符数据，返回值为int类型，真实有效数据为int类型的低16位
	int read(char[] buffer);	
		从文件中读取数据到字符数组buffer内，返回值类型是读取到的字符个数
	int read(char[] buffer, int offset, int length);	
		从文件中读取数据到字符数组buffer中，要求从offset位置开始存储数据，最大容量为length，返回值为真实读
		取到的字符个数

package com.qfedu.a_io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*
 * FileReader操作流程：
 * 	1. 明确文件
 * 	2. 创建FileReader对象，打开文件操作管道
 * 	3. 读取数据
 * 	4. 关闭资源
 */
public class Demo3 {
	public static void main(String[] args) throws IOException {
	
	}

	public static void readTest2() throws FileNotFoundException, IOException {
		// 1. 明确文件
		File file = new File("F:/aaa/你二大爷的.txt");

		// 2. 创建FileReader对象，打开文件操作管道
		FileReader fr = new FileReader(file);

		/*
		 * 3. 读取数据 
		 * 当前缓冲数组占用的字节空间为4KB
		 */
		char[] buffer = new char[1024 * 2];
		int length = -1;
		
		while ((length = fr.read(buffer)) != -1) {
			System.out.println(new String(buffer, 0, length));
		}

		// 4. 关闭资源
		fr.close();
	}

	public static void readTest1() throws FileNotFoundException, IOException {
		// 1. 明确文件
		File file = new File("F:/aaa/你二大爷的.txt");

		// 2. 创建FileReader对象，打开文件操作管道
		FileReader fr = new FileReader(file);

		/*
		 * 3. 读取数据 字符流读取数据会受到当前文件对应编码集和程序对于编码集问题
		 */
		System.out.println((char) fr.read());
		System.out.println((char) fr.read());
		System.out.println((char) fr.read());
		System.out.println((char) fr.read());
		System.out.println((char) fr.read());
		System.out.println((char) fr.read());

		// 4. 关闭资源
		fr.close();
	}
}

1.6 文件操作字符输出流

构造方法:
	FileWriter(String filePath);
		根据用户指定的文件路径(相对路径/绝对路径)，创建对应的FileWriter类对象
	FileWriter(File file);
		根据用户指定的File对象，创建对应的FileWriter类对象
	FileWriter(String filePath, boolean append);
		根据用户指定的文件路径(相对路径/绝对路径)，创建对应的FileWriter类对象。append对应数据为
		true，表示追加写
	FileWriter(File file, boolean append);
		根据用户指定的File对象，创建对应的FileWriter类对象。append对应数据为true，表示追加写
	
	补充说明 tips:
		1. FileWriter构造方法拥有创建文件的能力，如果当前指定的路径合法，并且有可写入权限，当前文件不
		存在的情况下，可以进行创建操作.
		2. FileWriter默认写入数据的方式【删除写/清空写】。首先删除当文件的所有内容，重写写入数据。如
		果要求完成追加写操作。需要在构造方法中，加入一个参数boolean append

成员方法:
	void write(int ch);
		写入一个字符数据到文件中
	void write(char[] arr);
		写入一个字符数组数据到文件中
	void write(char[] arr, int offset, int length);	
		写入一个字符数组数组到文件中，要求从指定位置offset开始，计数长度为length

package com.qfedu.a_io;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/*
 * FileWriter演示
 */
public class Demo4 {
	public static void main(String[] args) throws IOException {
		File file = new File("F:/aaa/土豆泥饺子.txt");
		
		FileWriter fw = new FileWriter(file, true);
		
		fw.write("ABCDEFG", 2, 3);
	
		fw.close();
	}
}

1.7 缓冲概念

空间 换 时间

IO流使用的缓冲实际上是【内存空间】

CPU ==> 内存 ==> 硬盘 ==> 内存 ==> CPU
CPU ==> 内存 ==> 缓冲(内存空间) ==> 硬盘 ==> 缓冲(内存空间) ==> 内存 ==> CPU

缓冲实际上是CPU使用一部分内存空间用于数据的临时存储，提高CPU操作数据的效率，同时降低内存访问读取硬盘的次数。
缓冲的使用可以极大的提高效率。

【所有的缓冲流都没有任何的读写能力，只是提供缓冲空间。读写能力依赖于对应的输入流和输出流】

1.8 字节缓冲流【重点】

字节输入缓冲流
	BufferedInputStream 有且只是提供缓冲空间和对应缓冲空间操作方法。【缓冲空间为8KB字节数组】
	构造方法:
		BufferedInputStream(InputStream in);
			字节输入缓冲流对象创建，需要对应的InputStream字节输入流对象作为构造方法参数，提供的对应的读取文
			件能力。所有读取文件相关方法，都是由InputStream提供。
	成员方法:
		int read();
		int read(byte[] buf);
		int read(byte[] buf, int off, int len);
			这里的所有操作不是从文件中读取数据，而是在BufferedInputStream缓冲区中读取数据。
字节输出缓冲流
	BufferedOutputStream 有且只是提供缓冲空间和对应缓冲空间操作方法。【缓冲空间为8KB字节数组】
	构造方法:
		BufferedOutputStream(OutputStream out);
        	字节缓冲输出流对象创建需要依赖于OutputStream 字节输出流对象，提供输出数据能力。
    成员方法:
    	void write(int b);
    	void write(byte[] buf);
    	void write(byte[] buf, int off, int len);
    		每一次调用write方法，不是直接写入数据到文件中，而且存储在对应的缓冲空间。有三种情况缓冲空间数据真
    		实的写入到文件中/输出
    			1. 缓冲区已满
    			2. 程序退出
    			3. 自行调用flush方法。

1.9 字符缓冲流

字符输入缓冲流
	BufferedReader 有且只是提供缓冲空间和对应缓冲空间操作方法。【缓冲空间为16KB字符数组】
	构造方法:
		BufferedReader(Reader in);
			字符输入缓冲流对象创建，需要对应的Reader字符输入流对象作为构造方法参数，提供的对应的读取文
			件能力。所有读取文件相关方法，都是由Reader提供。
	成员方法:
		int read();
		int read(char[] buf);
		int read(char[] buf, int off, int len);
		String readLine();
			从缓冲区中读取一行文本数据。行尾标记为\r\n
			这里的所有操作不是从文件中读取数据，而是在BufferedReader缓冲区中读取数据。
字符输出缓冲流
	BufferedWriter 有且只是提供缓冲空间和对应缓冲空间操作方法。【缓冲空间为16KB字符数组】
	构造方法:
		BufferedWriter(Writer out);
        	字符缓冲输出流对象创建需要依赖于Writer 字符输出流对象，提供输出数据能力。
    成员方法:
    	void write(int ch);
    	void write(char[] buf);
    	void write(char[] buf, int off, int len);
    	void newLine();
    		换行+回车在文件中写入一个\r\n
    		每一次调用write方法，不是直接写入数据到文件中，而且存储在对应的缓冲空间。有三种情况缓冲空间数据真
    		实的写入到文件中/输出
    			1. 缓冲区已满
    			2. 程序退出
    			3. 自行调用flush方法。