JAVA，IO的字符、字节流，缓冲流，转换流，打印流

本文主要介绍，字符，字节流，缓冲流，转换流，打印流。

一，字节流（输出，输入）：
1，输出流（字节输出流），写入方法写入，可以写一个字节，字节片段，也可以规定写入一部分字节的一部分。
2，InputStream（字节输入流），读取方法读取，可以读一个字节，字节片段，也可以规定读取某些字节片段的一部分。字符
流（Reader，Writer）：
1，FileWriter（字符输出流），写入方法写入，可以写一个字符，字符数组，也可以规定写入某些字符数组的一部分。
1，FileReader（字符输入流），读取方法read，可以读一个字符，字符数组，也可以规定读取某些字符片段的一部分。

注：字符流在写入的时候要刷新刷新一下，关闭方法中包含了刷新，但是一般还是写入部分刷新一下好。字符流和字节流的用法区别：

 一般文本操作的时候用字符流，其他文件操作的时候用字节流。因为汉字不管用什么编码表，都不止一个字节，用字节流来一个个读取会破坏汉字的特性。而用字符流来都其他文件（图片，音乐，视频），也会破坏本来的文件。

字符流，字节流，对文件的复制操作。（复制包含了读取和写入）

package note.basics.demo;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 分别用字符流和字节流来对文件的Copy
 */
public class Copy_1 {
	public static void main(String[] args) throws IOException {
		fun();
	}
	//字节流的操作
	public static void fun() throws IOException{
		//创建一个操作文件
		File file = new File("d:\\copy.txt");
		//把文件进行流的捆绑
		FileInputStream fis = new FileInputStream(file);
		FileOutputStream fos = new FileOutputStream(new File("d:\\aa.txt"));
		//当文件读取完了，返回-1,每次返回的是相对于的ASCII
		int read = -1;	
		while( (read = fis.read()) != -1){
			fos.write(read);
			//如果存的是汉字打印出来的是乱码
//			System.out.println((char)read);
		}
		fis.close();
		fos.close();
	}
	//字符流的操作
	public static void fun2() throws IOException{
		//创建字符输入输出流，并捆绑文件
		FileReader fr = new FileReader(new File("d:\\copy2.txt"));
		FileWriter fw = new FileWriter(new File("d:\\bb.txt"));
		int read = -1;
		while( (read = fr.read()) != -1){
			fw.write(read);
			//不管存的是什么，都照样输出
//			System.out.println((char)read);
		}
		fr.close();
		fw.close();
	}
}

二，缓冲流：

1，字节缓冲流（BufferedInputStream，BufferedOutputStream）
1）BufferedOutputStream（字节输出缓冲流）：写入数据到流中，作用：提高写入输出流的写入效率。
2）BufferedInputStream（字节输出缓冲流）：读取流中的数据，作用：提高内置输入流的读取效率。

2，字符缓冲流（BufferedReader，BufferedWriter）
1）BufferedReader（字符读取缓冲流）：从字符输入流中读取文本，缓冲多个字符，从而实现字符，数组和行的高效读取。
2）BufferedWriter（字符写入缓冲流）：将文本写入字符串输出流，缓冲多个字符，从而提供字符串，字符串和字符串的高效写入。

注：它们的构造方法都有两个，一个是一个参数的，一个是两个参数的。

1）一个参数的，都是传递相对应的流，进行效率的提高。（以下会代码演示）
2）两个参数的，第一个参数和（1）一样，第二个参数是输入的大小。一般尺寸大小也够，看实际情况来选择方法。

缓冲流对文件复制（复制包含文件的读取，和写入）

package note.basics.demo;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Copy_2 {
	public static void main(String[] args) throws IOException{
		fun();
		fun1();
	}
	//字节缓冲流复制
	public static void fun() throws IOException{
		//创建字节输入输出并为其绑定文件
		FileInputStream fis = new FileInputStream(new File("d:\\copy.txt"));
		FileOutputStream fos = new FileOutputStream(new File("d:\\aa.txt"));
		//创建字节缓冲流并绑定相对应的字节流
		BufferedInputStream bis = new BufferedInputStream(fis);
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		//read方法可以读取一个字节或字节数组,或读取字节数组的一部分
		int line = -1;
		while((line = bis.read()) != -1){
			//write方法可以写入一个字节或字节数组,或写入字节数组的一部分
			bos.write(line);
		}
		//关闭流
		//直接关闭缓冲流就可以了，它会把相对应的字节流也关闭
		bis.close();
		bos.close();
	}
	//字符缓冲流复制
	public static void fun1() throws IOException{
		//直接一步创建字符缓冲流并绑定文件
		BufferedReader br = new BufferedReader(new FileReader("d:\\copy2.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\bb.txt"));
		int line = -1;
		while((line = br.read()) != -1){
			bw.write(line);
			//字符流写入的时候要刷新
			bw.flush();
		}
		br.close();
		bw.close();


		//这里介绍两个比较好用的方法
		//读取文本中的一行，返回String 结束返回null
		String readLine = br.readLine();
		//向文本中写入换行
		bw.newLine();
		bw.write("\r\n");//这个也是向文本中写入换行
		//但是 newLine更好，因为它可以跨平台
		//\r\n是win系统的换行 Linux下是 \r
	}
}

 

三，转换流：

1，InputStreamReader是字节流通向字符流的轴向，读取字节相连其解码为字符。
2，OutputStreamWriter是字符流通向字节流的轴向，将要写入流中的字符编码成字节。

总结：有了这两个转换流就可以完成所有的转换。
1，读取字符转换成字节
2，读取字节转换成字符

用代码展示这两种转换：

package note.basics.demo;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/*
 * 这两个转换流都有两个构造方法：
 * 		1、一个是一个参数的，是相对应的流
 * 		2、另一个是两个参数的，第一个参数是相对应的流，第二个参数是指定编码
 * 		默认编码是GBK，只有GBK和utf-8两种，不区分大小写
 * 
 * 它们都有一个方法	getEncoding(),返回当前转换流使用的编码
 * 
 */
public class Demo {
	public static void main(String[] args) throws IOException {
		fun();
		fun1();
	}
	//向文件中写入字符
	public static void fun() throws IOException{
		FileWriter fw = new FileWriter("d:\\aa.txt");
		fw.write("你好");
		fw.close();
	}
	//将写入的字符变成字节
	public static void fun1() throws IOException{

		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\bb.txt"),"UTF-8");
		osw.write("你好");
		osw.close();
	}
	//读取字节转换成字符
	public static void fun2() throws IOException{

		InputStreamReader isr = new InputStreamReader(new FileInputStream("d:\\bb.txt"),"utf-8");
		int line = -1;
		while((line = isr.read()) != -1){
			System.out.print((char)line);
		}
		isr.close();
	}
	/*
	 * 结果：
	 * 		fun2()函数去读aa.txt文件的时候打印出来的结果是  		???
	 * 		fun2()函数去读bb.txt文件的时候打印出来的结果是		你好
	 * 
	 * 结论：
	 * 		OutputStreamWriter流成功把字符转换成了字节
	 * 		OutputStreamWriter流成功把字节转换成了字符
	 * 
	 */

}

四，打印流

1，PrintStream继承OutputStream
2，PrintWriter继承Writer

特点：
1，此流不负责数据源，只负责数据目的
2，为其他输出流，添加功能
3，永远不会引发IOException，但是可能引发别的异常

package note.basics.io;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;

/*
 * 打印流
 * 		PrintStream
 * 		PrintWriter
 *  
 * 	两个打印流的方法，完全一致
 * 	构造方法就是打印流的输出目的端
 * 	PrintStream
 * 		构造方法：接受File类型，接受字符串文件名，接受字节输出流OutputStream
 * 	PrintWriter
 * 		构造方法：接受File类型，接受字符串文件名，接受字节输出流OutputStream，接受字符输出流Writer
 */
public class io15 {
	public static void main(String[] args) throws IOException {
		fun3();
	}
	/*
	 * 打印流，向File对象的数据目的写入数据
	 * 方法print println 原样输出
	 * write 走码表
	 */
	public static void fun() throws FileNotFoundException{
		File file = new File("d:\\1.txt");
		PrintWriter pw = new PrintWriter(file);
		pw.print(100);
		pw.close();
	}
	/*
	 * 打印流，输出目的，String文件名
	 */
	public static void fun1() throws FileNotFoundException{
		PrintWriter pw = new PrintWriter("d:\\2.txt");
		pw.println(3.5);
		pw.close();
	}
	/*
	 * 打印流，输出目的，是流对象
	 * 可以是字节输出流，可以是字符的输出流
	 * OutputStream Writer
	 */
	public static void fun2() throws FileNotFoundException{

		FileOutputStream fos = new FileOutputStream("d:\\3.txt");
		PrintWriter pw = new PrintWriter(fos);
		pw.print("dada");
		pw.close();
	}
	/*
	 * 打印流，可以开启自动刷新功能
	 * 满足2个条件：
	 * 		1、输出的数据目的必须是流对象
	 * 			OutputStream Writer
	 * 		2、必须调用println，printf，format三个方法中的一个，启用自动刷新
	 * 
	 */
	public static void fun3() throws IOException{
		FileOutputStream fos = new FileOutputStream("d:\\5.txt");
		PrintWriter pw = new PrintWriter(fos,true);
		pw.println("d");
		pw.println("a");
		pw.println("s");
		pw.println("f");
		pw.close();
	}
}