Java IO操作—字节流(OutputStream、InputStream)和字符流(Writer、Reader)

流的概念

在程序中所有的数据都是以流的方式进行传输或保存的，程序中需要数据的时候就用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。

程序中的输入输出都是以流的形式保存的，流中保存的实际上全部是字节文件。

字节流和字符流

在java.io包中操作文件内容的主要有两大类：字节流和字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使用InputStream，在字符流中输出主要是使用Writer类完成，输入主要是使用Reader类完成。
内容操作一共四个类：OutputStream、InputStream、Writer、Reader
操作流程：
在JAVA中IO操作也是有相应步骤的，以文件操作为例，主要操作流程如下：
A、使用File类打开一个文件
B、通过字节流或字符流的子类，指定输出的位置。
C、进行读/写操作
D、关闭输入/输出

使用File类操作的时候一定要有路径的问题，注意分隔符。
实际上四个操作类都是抽象类
IO操作属于资源操作，对于资源操作，操作的最后必须关闭，否则就有可能出现未知的错误。

字节流

字节流主要是操作byte类型的数据，以byte数组为准，主要操作类是OutputStream、InputStream
字节输出流：OutputStream
字节输入流：InputStream
Byte是字节，肯定使用字节流操作。所有的数据基本上都可以直接使用byte数组表示出来。

字节输出流OutputStream

OutputStream是整个io包中字节输出流的最大父类，此类的定义如下：
public abstract class OutputStream extends Object implements Closeable, Flushable
从以上的定义可以发现，此类是一个抽象类，如果要想使用此类的话，则首先必须通过子类实例化对象，那么如果现在要操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型之后，可以为OutputStream实例化。
Closeable表示可以关闭的操作，因为程序运行到最后肯定要关闭。
Flushable接口表示刷新，清空内存中的数据。

OutputStream类的常用方法：

1、public void close() throws IOException 关闭输出流
2、public void flush() throws IOException 刷新缓冲区
3、public void write(byte[] b) throws IOException 将一个byte数组写入数据流
4、public void write(byte[] b,int off,int len) throws IOException 将一个指定范围的byte数组写入数据流
5、public abstract void write(int b) throws IOException 将一个字节数据写入数据流

要想使用以上方法，必须使用子类实例化，此时使用FileOutputStream子类，此类的构造方法如下：
public FileOutputStream(File file) throws IOException

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo01{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		OutputStream out = null ;	// 准备好一个输出的对象
		out = new FileOutputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		byte b[] = str.getBytes() ;			// 只能输出byte数组，所以将字符串变为byte数组
		out.write(b) ;						// 将内容输出，保存文件
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}
};

在操作的时候，如果文件本身不存在，则会为用户自动创建新文件。
在操作输出流的时候，也可以使用write(int i)的方法写出数据：

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo02{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		OutputStream out = null ;	// 准备好一个输出的对象
		out = new FileOutputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		byte b[] = str.getBytes() ;			// 只能输出byte数组，所以将字符串变为byte数组
		for(int i=0;i<b.length;i++){		// 采用循环方式写入
			out.write(b[i]) ;	// 每次只写入一个内容
		}
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}
};

FileOutputStream的另外一个构造方法：
public FileOutputStream(File file,boolean append) throws FileNotFoundException
在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容。

字节输入流：InputStream

既然程序可以向文件中写入内容，则就可以通过InputStream从文件中读取出来，首先看InputStream类的定义：
public abstract class InputStream extends Object implements Closeable
与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，子类肯定是FileInputStream。观察FileInputStream类的构造方法：
public FileInputStream(File file) throws FileNotFoundException
InputStream类的常用方法如下：

1、public int available() throws IOException 可以取得输入文件的大小。
2、public void close() throws IOException 关闭输入流
3、public abstract int read() throws IOException 读取内容数字的方式读取
4、public int read(byte[] b) throws IOException 将内容读取到byte数组之中，同时返回读入的个数

当不知道输入流大小时，需要根据读取的标志-1进行判断是否结束，程序代码如下：

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo05{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		InputStream input = null ;	// 准备好一个输入的对象
		input = new FileInputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		byte b[] = new byte[1024] ;		// 数组大小由文件决定
		int len = 0 ; 
		int temp = 0 ;			// 接收每一个读取进来的数据
		while((temp=input.read())!=-1){
			// 表示还有内容，文件没有读完
			b[len] = (byte)temp ;
			len++ ;
		}
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流\
		System.out.println("内容为：" + new String(b,0,len)) ;	// 把byte数组变为字符串输出
	}

字符流

在程序中一个字符等于2个字节，那么JAVA提供了Reader、Writer两个专门操作字符流的类。

字符输出流：Writer

Writer本身是一个字符流的输出类，此类的定义如下：
public abstract class Writer extends Object implements Appendable，Closeable,，Flushable
此类也是一个抽象类，如果要想使用此类，则肯定要使用其子类。此时如果是向文件中写入内容，所以应该使用FileWriter的子类。
FileWriter类的构造方法定义如下：
public FileWriter(File file) throws IOException
Writer类的常用方法

1、public abstract void close() throws IOException 关闭输出流
2、public void write(String str) throws IOException 将字符串输出
3、public void write(char[] cbuf) throws IOException 将字符数组输出
4、public abstract void flush() throws IOException 强制性清空缓存

字符流的操作比字节流操作好在一点，就是可以直接输出字符串。不在用再像之前那样进行字节转换操作了。

import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo01{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		Writer out = null ;	// 准备好一个输出的对象
		out = new FileWriter(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		out.write(str) ;						// 将内容输出，保存文件
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}

字符输入流：Reader
Reader是使用字符的方式从文件之中取出数据，Reader类的定义如下：
public abstract class Reader extends Object implements Readable，Closeable
Reader本身也是抽象类，如果现在要从文件中读取内容，则可以直接使用FileReader子类。
FileReader的构造方法定义如下：
public FileReader(File file) throws FileNotFOundException
Reader类的常用方法：

1、public abstract void close() throws IOException 关闭输出流
2、public int read() throws IOException 读取单个字符
3、public int read(char[] cbuf) throws IOException 将字符读取到字符数组之中，返回读入的长度。

以字符数组的形式读取数据

import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class ReaderDemo01{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		Reader input = null ;	// 准备好一个输入的对象
		input = new FileReader(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		char c[] = new char[1024] ;		// 所有的内容都读到此数组之中
		int len = input.read(c) ;		// 读取内容
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流
		System.out.println("内容为：" + new String(c,0,len)) ;	// 把字符数组变为字符串输出
	}
};

字节流与字符流的区别

字节流在操作的时候本身是不会用到缓冲区(内存)的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的。