详述IO流

IO流

I是指Input（输入）,O是指Output（输出）。
在Java中，文件的输入和输出是通过流（Stream）来实现的，流的概念源于Unix中管道（pipe）的概念。在Unix系统中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。
一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。对于流而言，我们不用关心数据是如何传输的，只需要向源端输入数据，向目的端获取数据即可。
流按照处理数据的单位，可以分为字节流和字符流；按照流向分为输入流和输出流（注意：输入流和输出流都是站在程序的角度参照的）。
 

字节流

字节流用于处理以字节为单位的二进制文件（如音乐、图片等）。
InputStream抽象类是所有输入字节流类的直接或间接父类，FileInputStream是其重要子类。

FileInputStream常用构造方法：
FileInputStream(File file) ：通过File对象创建FileInputStream对象。
FileInputStream(String name) ：通过文件（非“目录”）路径创建FileInputStream对象。

FileInputStream常用方法：
int read()：从输入流中读取单个字节的数据；如果已到达文件末尾，则返回 -1。
int read(byte[] b)：从输入流中将最多b.length个字节的数据读入一个byte数组中，以整数形式返回存入数组中的实际字节个数；如果已到达文件末尾，则返回 -1。
void close()：关闭此文件输入流并释放与此流有关的所有系统资源。

OutputStream抽象类是所有输出字节流类的直接或间接父类，FileOutputStream是其重要子类。

FileOutputStream常用构造方法：
FileOutputStream(File file) ：通过File对象创建FileOutputStream对象。
FileOutputStream(String name) ：通过文件（非“目录”）路径创建FileOutputStream对象。
FileOutputStream(File file, boolean append)：通过File对象创建FileOutputStream对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头。

FileOutputStream常用方法：
void write(int b)：将指定的单个字节数据写入此文件输出流。
void write(byte[] b, int off, int len)：将byte数组中从off开始的len个字节写入此文件输出流。
void flush()：刷新字节输出流并强制写出缓冲内所有字节数据。
void close()：关闭此文件输出流并释放与此流有关的所有系统资源。

注意： FileOutputStream(File file) 、 FileOutputStream(String name) 或FileOutputStream(File file, false)创建FileOutputStream对象时会创建一个新的空文件；如果使用FileOutputStream(File file, true)创建FileOutputStream对象，则只在第一次执行时创建一个新的空文件。

例1：

File a = new File("D:\\1.png");//创建源文件File对象
File b = new File("D:\\Desktop\\1.png");//目的文件File对象

FileInputStream inputStream = new FileInputStream(a);//创建FileInputStream对象
FileOutputStream outputStream = new FileOutputStream(b);//创建FileOutputStream对象


int data;
while ((data = inputStream.read())!=-1){//从源文件逐个字节地读取数据，直到读取完毕。
    outputStream.write(data);//向目的文件逐个字节地传输数据。
}

其中，前两行代码就如同创建了两个数据池子，a是源头，b是目的地；data就相当于中间的中转站，中间代码就相当于给三个池子接上管道，一个inputStream 管道，一个outputStream 管道。

 

正如注释所述，此传输方式为将数据一个字节一个字节地读取，再一个字节一个字节地输入，效率低下。

有另外一种方式：

File a = new File("D:\\1.png");
File b = new File("D:\\Desktop\\1.png");

FileInputStream inputStream = new FileInputStream(a);
FileOutputStream outputStream = new FileOutputStream(b);

byte [] car = new byte[1024];    //小推车，一次传输1024字节数据
int length = 0;                  //length代表小推车中一次承装的字节数
while ((length = inputStream.read(car))!=-1){
    System.out.println(length);  //输出每次传输字节数
    outputStream.write(car,0,length);    //将小推车中的数据送至目的文件
}

将原来逐个字节传输变为一次传输1024字节，相当于传输速度变为原来的1024倍。

字符流：

Java虚拟机将字节转化为2个字节的Unicode字符就形成了字符流，字符流用于处理以Unicode字符为单位的文本文件（如记事本文件等）。
Reader抽象类是所有输入字符流类的直接或间接父类， FileReader是其重要子类。

FileReader常用构造方法：
FileReader(File file) ：通过File对象创建FileReader对象。
FileReader(String fileName) ：通过文件（非“目录”）路径创建FileReader对象。

FileReader常用方法：
int read()：从输入流中读取单个字符的数据，如果已到达流的末尾，则返回 -1 。 
int read(char[] cbuf)：从输入流中将最多cbuf.length个字符的数据读入一个char数组中，以整数形式返回存入数组中的实际字节个数，如果已到达流的末尾，则返回 -1 。
void close()：关闭此文件输入流并释放与此流有关的所有系统资源。

Writer抽象类是所有输出字符流类的直接或间接父类，FileWriter是其重要子类。
FileWriter常用构造方法：
FileWriter(File file) ：通过File对象创建FileWriter对象。
FileWriter(String fileName) ：通过文件（非“目录”）路径创建FileWriter对象。
FileWriter(File file, boolean append)：通过File对象创建FileWriter对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头。

FileWriter常用方法：
void write(int c)：将指定的单个字符数据写入此文件输出流。
void write(char[] cbuf, int off, int len)：将char数组中从off开始的len个字符写入此文件输出流。
void flush()：刷新字符输出流缓冲。 
void close()：关闭此文件输出流并释放与此流有关的所有系统资源。

注意： FileWriter (File file) 、 FileWriter (String fileName) 或FileWriter (File file, false)创建FileWriter对象时会创建一个新的空文件；如果使用FileWriter (File file, true)创建FileWriter对象，则只在第一次执行时创建一个新的空文件。

例2:

FileReader reader = new FileReader("D:\\1.txt");//创建FileReader对象，即源数据池。
FileWriter writer = new FileWriter("D:\\Desktop\\1.txt");//创建FileWriter对象，即目的数据池。

int data;
while ((data = reader.read())!=-1){//将字符数据逐字符地读取。
    writer.write(data);//将字符数据逐字符地传送至目的地。
}
writer.flush();//刷新字节输出流并强制写出缓冲内所有字节数据。相当于将传输残留在管壁上的水珠冲净。

与字节流相似，由于是逐个字符传输数据，这种方式仍然效率不高。

改进方式：

FileReader reader = new FileReader("D:\\1.txt");
FileWriter writer = new FileWriter("D:\\Desktop\\1.txt");
char [] car = new char[128];    //小车，最多存放128个字符
int length;                     //小车中存放的多少字符
while ((length = reader.read(car))!=-1){//每次最多读取128个字符数据
    writer.write(car,0,length);//每次最多运送128个字符数据
}
writer.flush();

缓冲流

以上说明的传输方式，无论对源文件还是目标文件，都是直接与物理数据源（硬盘）直接交互，这种方式速度较慢。

通过开辟缓冲区间可加快数据的传输。

缓冲流是一种装饰器类，目的是让原字节流、字符流新增缓冲的功能以提高读取或写入。
缓冲字节输入流：
BufferedInputStream(InputStream in)：
缓冲字节输出流：
BufferedOutputStream(OutputStream out)：
 

BufferedInputStream继承于FilterInputStream，提供缓冲输入流功能。缓冲输入流相对于普通输入流的优势是，它提供了一个缓冲数组，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快。

例3：

FileInputStream inputStream = new FileInputStream("D:\\1.png");
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);//相当于在inputStream这个管道上安置了一个缓存区。
FileOutputStream outputStream = new FileOutputStream("D:\\Desktop\\1.png");
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);//相当于在outputStream 这个管道上安置了一个缓存区。

byte [] car = new byte[1024];
int length = 0;
while ((length = bufferedInputStream.read(car))!=-1){
    System.out.println(length);
    bufferedOutputStream.write(car,0,length);
}
bufferedOutputStream.flush();
bufferedOutputStream.close();
bufferedInputStream.close();

//字符流，与上面字节流类似
FileReader reader = new FileReader("D:\\1.txt");
BufferedReader bufferedReader = new BufferedReader(reader);
FileWriter writer = new FileWriter("D:\\Desktop\\1.txt");
BufferedWriter bufferedWriter = new BufferedWriter(writer);
char [] car = new char[128];
int length;
while ((length = bufferedReader.read(car))!=-1){
    bufferedWriter.write(car,0,length);
}
bufferedWriter.flush();
bufferedWriter.close();
bufferedReader.close();

转换流

由于文件自身编码方式和程序运行时使用的默认编码方式不一致，致使程序读取或输出字符文件时可能会出现乱码，这时可以使用字节流操作文件，然后再将字节流转换成字符流，这一转换过程可以借助转换流实现。
InputStreamReader（字节输入流→字符输入流）：
InputStreamReader(InputStream in) ；
InputStreamReader(InputStream in, String charsetName)；
OutputStreamWriter（字节输出流→字符输出流）：
OutputStreamWriter(OutputStream out) ；
OutputStreamWriter(OutputStream out, String charsetName) 

根据前面所学知识，可以通过字符流或者缓冲字符流实现文本文件的复制，但是这种复制方法有可能会出现乱码，为了解决该问题可以通过字节流+转换流实现文本文件的复制。

例4：

FileInputStream inputStream = new FileInputStream("D:\\1.txt");
InputStreamReader reader = new InputStreamReader(inputStream,"GBK");//转换流对象，将原来字节流转换为字符流，并且统一使用GBK编码
FileOutputStream outputStream = new FileOutputStream("D:\\Desktop\\1.txt");
OutputStreamWriter writer = new OutputStreamWriter(outputStream,"GBK");
char [] car = new char[128];
int length;
while ((length = reader.read(car))!=-1){
    writer.write(car,0,length);
}
writer.flush();