------- android培训、java培训、期待与您交流！ ----------
IO流在是java中非常重要，也是应用非常频繁的一种技术。初学者要是能把IO技术的学透，java基础也就能更加牢靠。本文是根据以前学习IO的过程中的一些总结，再通过查找资料完善出来的，应该算是比较适合初学者解读的。
一、概念
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输。所以，为了方便更直观的进行数据操作，就根据数据传输特性将流抽象为各种类。
一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。
流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往输入流写，而不能读它。
我们可以把形象的比喻成水流 ，文件和程序之间连接一个管道，水流就在之间形成了,自然也就出现了方向：可以流进，也可以流出。
二、流的分类
1.根据从流本身的特点来说，可以分为结点流(nodestream)和过滤流(filters)。
（1）结点流直接从指定的位置（如磁盘文件或内存区域）读或写。（如FileOutputStream和FileInputstream）
（2）过滤流输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，过滤流输出流的原理也类似。（如ObjectOutputStream和ObjectInputStream）
2.根据流操作对象的类型是字节还是字符可分为两大类： 字节流和字符流。
（1）字节流，顾名思义，是操作字节的流，而字节也是最基本的存储单位，所以字节流是最基本的流。它对应有字节输入流和字节输出流（Inputstream和OutputStream）。
（2）字符流，是操作字符的流。我们应该知道，字符是从字节根据编码表编码而来的，而编码表不是唯一的，这就造成了同样的字节数据，如果根据的编码表不一样，那么最终得到的字符也就不一样。所以为了对字符进行高效操作，就有了字符流。总的来说，字符流本质上是基于字节流读取时，查询了指定的码表。字符流也对应有字符输入流和字符输出流（Reader和Writer）。
字节流和字符流的区别可以归纳一下：
（1）读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
（2）处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
（3）字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的；而字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件。
三、一般使用原则
java类库中，还包含很多流对象，我们可以看一下他们的派生关系，如下图示意：
那么，这么多的流对象，使用中如何选择？
我们先把流对象按特点划分一下：
1.按数据来源和目的：
（1）是文件： FileInputStream, FileOutputStream, FileReader, FileWriter
（2）是byte[]：ByteArrayInputStream, ByteArrayOutputStream
（3）是Char[]: CharArrayReader, CharArrayWriter
（4）是String: StringBufferInputStream, StringReader, StringWriter
（5）网络数据流：InputStream, OutputStream, Reader, Writer
2.按是否格式化输出：
要格式化输出：PrintStream,PrintWriter
3.按是否要缓冲：
要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader,BufferedWriter
4.按数据格式：
（1）二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream及其所有带Stream结束的子类
（2）纯文本格式（含纯英文与汉字或其他编码方式）；Reader, Writer及其所有带Reader, Writer的子类
5.按输入输出：
（1）输入：Reader, InputStream类型的子类
（2）输出：Writer, OutputStream类型的子类
6.特殊需要：
（1）从Stream到Reader,Writer的转换类：InputStreamReader, OutputStreamWriter
（2）对象输入输出：ObjectInputStream, ObjectOutputStream
（3）进程间通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
（4）合并输入：SequenceInputStream
（5）更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream,LineNumberReader
基于以上各个流的特点，我们在使用IO流时，可按一下步骤判断选择：
（1）考虑最原始的数据格式是什么：是否为文本？
（2）是输入还是输出?
（3）是否需要转换流：InputStreamReader, OutputStreamWriter?
（4）数据来源和目的是什么：文件？内存？网络？
（5）是否要缓冲：bufferedReader等 ?
（6）是否要格式化输出：print?
四、应用
1.例子一（字节流复制图片）：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
要求：复制一张图片。
需求分析：
1，原始的数据格式是什么：是否为文本？
原始数据是图片，所以用字节流。
2，是输入还是输出?
需要复制，所以需要输入和输出。
3，是否需要转换流?
因为操作过程中只涉及字节，所以不需要转换流。
4，数据来源和目的是什么：文件？内存？网络？
数据源是硬盘，写入目的地也是硬盘。所以使用FileInputStream和FileOutputStream。
5，是否要缓冲？
不需要使用缓冲。
6，是否要格式化输出？
不需要格式化输出。
思路：
1，用字节读取流对象和图片关联。
2，用字节写入流对象创建一个图片文件，用于存储获取到的图片数据。
3，通过循环读写，完成数据存储。
4，关闭资源。
*/
public class CopyPicTest {
public static void main(String[] args) {
FileOutputStream fos = null;
FileInputStream fis = null;
try
{
// 定义读取和写入目的文件。如果文件在多层路径下，可以先定义File。
fos = new FileOutputStream("d:\\Miku_Toxic_Copy.jpg");
fis = new FileInputStream("c:\\Miku_Toxic.jpg");
byte[] buf = new byte[1024*4]; //先把字节写入到字节数组中。
int len = 0;
while ((len=fis.read(buf))!=-1)
{
fos.write(buf,0,len); //再把字节数组中的元素写入目的文件。
}
}
catch (IOException e)
{
throw new RuntimeException("复制文件失败");
}
finally
{
try
{
if(fis!=null)
fis.close();
}
catch (IOException e1)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(fos!=null)
fos.close(); // 流使用完必须要关闭，释放系统资源。在finally块中关闭就是为了保证执行关闭动作。
}
catch (IOException e1)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
需要注意的是，任何流最终都必须要关闭，释放系统资源。所以可以把关闭资源的动作，放在fially块中来保证执行。
2.例子二（字符流复制文本文件）：（为了方便阅读异常做抛处理）
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
要求：复制文本文件。
需求分析：
1，原始的数据格式是什么：是否为文本？
原始数据是文本文件，所以用字符流。
2，是输入还是输出?
需要复制，所以需要输入和输出。
3，是否需要转换流?
因为操作过程中只涉及字符，所以不需要转换流。
4，数据来源和目的是什么：文件？内存？网络？
数据源是硬盘，写入目的地也是硬盘。所以使用FileReader和FileWriter。
5，是否要缓冲？
有和没有缓冲的情况都有。
6，是否要格式化输出？
不需要格式化输出。
*/
public class CopyFileTest {
public static void main(String[] args) throws IOException{
readAndWriteFile_1();
readAndWriteFile_2();
readAndWriteFile_3();
}
public static void readAndWriteFile_1()throws IOException
{
FileReader fr = new FileReader("c:\\fr.txt");
FileWriter fw = new FileWriter("d:\\fw1.txt");
int ch = 0;
while ((ch=fr.read())!=-1) { //读一个字符，写一个字符。
fw.write(ch);
fw.flush(); //字符流写入时，需要刷新。
}
// 流使用完，必须要关闭。
fr.close();
fw.close();
}
public static void readAndWriteFile_2() throws IOException
{
FileReader fr = new FileReader("fos.txt");
FileWriter fw = new FileWriter("d:\\fos2.txt");
char[] cha = new char[1024]; //先把字符写入到字符数组中。
int len = 0;
while ((len=fr.read(cha))!=-1) {
fw.write(cha,0,len); //再把字符数组中的元素写入目的文件。
fw.flush(); //字符流写入时，需要刷新。
}
// 流使用完，必须要关闭。
fr.close();
fw.close();
}
public static void readAndWriteFile_3() throws IOException
{
FileReader fr= new FileReader("fos.txt");
FileWriter fw = new FileWriter("d:\\fos3.txt");
// 使用缓冲区。
BufferedReader bufr = new BufferedReader(fr);
BufferedWriter bufw = new BufferedWriter(fw);
String len = null;
while ((len=bufr.readLine())!=null) { //每次把文本中的一行读进缓冲区（不含换行符）。
bufw.write(len); //再把一行数据写入目的文件（不含换行符）。
bufw.newLine(); //换行方法。
bufw.flush(); //字符流需要刷新。
}
// 流使用完，必须要关闭。
bufr.close();
bufw.close();
}
}
前面有提过，字符流本身实际有使用缓冲技术，所以写入的时候需要手动刷新，让缓冲区的数据（内存）刷新到目的地。
3.例子三（转换流，将键盘录入数据保存为文本文件）
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
/*
要求：录入键盘数据，保存到文本文件。
需求分析：
1，原始的数据格式是什么：是否为文本？
源数据是字节流。目的数据是字符流。
2，是输入还是输出?
需要读取和写入，所以需要输入和输出。
3，是否需要转换流?
因为操作过程中有字节和字符，需要转换流。
4，数据来源和目的是什么：文件？内存？网络？
数据源是键盘录入，写入目的地是硬盘。所以使用InputStreamReader和FileWriter。
5，是否要缓冲？
需要。使用BufferedReadr和BufferedWriter。
6，是否要格式化输出？
不需要格式化输出。
*/
public class TransStream {
public static void main(String[] args) {
System.out.println("请输入要保存到文件中的内容（输入over结束）：");
// System.in录入键盘数据得到的是字节流，如要用字符流的方式读取，必须要先将字节流转成字符流。
InputStreamReader isr = new InputStreamReader(System.in);
// 使用缓冲区读写更加效率。
BufferedReader bufr = new BufferedReader(isr);
BufferedWriter bufw = null;
try {
// 也可以通过OutputStreamWriter来指定编码表。
// bufw = new BufferedWriter(new OutputStreamWriter("c:\\systemin.txt","UTF-8"));
bufw = new BufferedWriter(new FileWriter("c:\\systemin.txt"));
String str = null;
while ((str=bufr.readLine())!=null) {
if ("over".equals(str))
System.exit(0); //如果键盘录入over，则结束。
bufw.write(str);
bufw.newLine();
bufw.flush();
}
} catch (IOException e) {
throw new RuntimeException("找不到目标文件或写入数据失败");
} finally {
try {
if (bufw!=null) {
bufr.close();
bufw.close();
}
} catch (IOException e) {
throw new RuntimeException("关闭资源失败");
}
}
}
}
从以上例子可以看出，转换流是字符流和字节流之间的桥梁，我们实际也可以利用转换流把文本文件中的内容打印到控制台上。也就是说可以通过转换流让字符流和字节流相互转换。
另外要注意的是，将字节转换成字符的时，想按照指定的码表来转换，也可以通过OutputStreamWriter（OutputStream out，CharsetEncoder enc）的方式指定，其中enc即代表码表的名字，如"UTF-8","ISO 8859-1"等。
4.例子四（利用打印流把键盘录入数据保存到文件）：
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
/*
要求：录入键盘数据，保存到文本文件。
需求分析：
1，原始的数据格式是什么：是否为文本？
源数据是字节流。目的数据是字符流。
2，是输入还是输出?
需要读取和写入，所以需要输入和输出。
3，是否需要转换流?
因为操作过程中有字节和字符，需要转换流。
4，数据来源和目的是什么：文件？内存？网络？
数据源是键盘录入，写入目的地是硬盘。所以使用InputStreamReader和FileWriter。
5，是否要缓冲？
需要。使用BufferedReadr。
6，是否要格式化输出？
需要格式化输出。使用PrintWriter。
*/
public class PrintStream {
public static void main(String[] args) throws IOException{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
// PrintWriter可以设置刷新模式，如果刷新模式为true，那么PrintWriter部分方法输出是会自动刷新。
PrintWriter out = new PrintWriter(new FileWriter("c:\\a.txt"),true);
String line = null;
while ((line=bufr.readLine())!=null)
{
// 如果键盘输入over，则结束程序。
if("over".equals(line))
break;
// 因为PrintWriter设置有刷新模式，不需再手动刷新。
out.println(line.toUpperCase());
}
bufr.close();
out.close();
}
}
看完例子，在看看打印流的特点：
打印流：
该流提供了打印方法，可以将各种数据类型的数据都原样打印。
字节打印流：
PrintStream
构造函数可以接收的参数类型：
（1）file对象。File
（2）字符串路径。String
（3）字节输出流。OutputStream
字符打印流：
PrintWriter
构造函数可以接收的参数类型：
（1）file对象。File
（2）字符串路径。String
（3）字节输出流。OutputStream
（4）字符输出流。Writer
可以看出，字符打印流相对来说适用性更强。
5.例子五（LineNumberReader）：
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
public class LineNumberReaderDemo {
public static void main(String[] args)throws IOException {
FileReader fr = new FileReader("PersonDemo.java");
LineNumberReader lnr = new LineNumberReader(fr);
String line = null;
lnr.setLineNumber(100);
while((line=lnr.readLine())!=null)
System.out.println(lnr.getLineNumber()+":"+line);
lnr.close();
}
}
从 以上例子可以看出，LineNumberReader属于过滤流，而它实际的功能也是在字符写入流的基础上，加上获取行号（getLineNumber()），设置行号（setLineNumber()）的功能。LineNumberOutputStream同理，这里不再做阐述。
6.例子六（数据流）：
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataStreamDemo
{
public static void main(String[] args) throws IOException{
writeData();
readData();
}
public static void readData()throws IOException{
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
int num = dis.readInt();
boolean b = dis.readBoolean();
double d = dis.readDouble();
System.out.println("num="+num);
System.out.println("b="+b);
System.out.println("d="+d);
dis.close();
}
public static void writeData()throws IOException{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(234);
dos.writeBoolean(true);
dos.writeDouble(9887.543);
dos.close();
}
}
以上运行结果是：
234
true
9887.543
从例子可以看出数据流的特点：
DataInputStream和DataOutputStream，经常用来处理基本数据类型的数据，好处就是可以按类型来处理数据。
7.例子七（数组流）：
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
public class ByteArrayStream {
public static void main(String[] args) {
//数据源。
ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());
//数据目的，数组输出流输出的数据目的地是内存。
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int by = 0;
while((by=bis.read())!=-1)
bos.write(by);
System.out.println(bos.size());
System.out.println(bos.toString());
// 最后内存中流的数据可以通过writeTo方法输出到其他节点流中，将数据保存到目的地。
// bos.writeTo(new FileOutputStream("a.txt"));
}
}
运行结果为：
7
ABCDEFD
数组流是用于操作字节数组的流对象，它是使用流的思想来操作数据的体现。
ByteArrayInputStream ：在构造的时候，需要接收数据源，而且数据源是一个字节数组。
ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组，这就是数据目的地（在内存中）。
因为这两个流对象都操作的数组，并没有使用系统资源。
所以，不用进行close关闭。
8.例子八（RandomAccessFile）：
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo {
public static void main(String[] args) throws IOException{
writeFile();
writeFile_2();
readFile();
}
public static void readFile()throws IOException{
RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
//调整对象中指针，以8为单位是因为两个中文字4个字节加上int数据的4个字节。
//raf.seek(8*1);
//跳过指定的字节数
raf.skipBytes(8);
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println("name="+name); //结果为周七。
System.out.println("age="+age);
raf.close();
}
// 也能修改指定指针上的数据。
public static void writeFile_2()throws IOException{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.seek(8*0);
raf.write("周七".getBytes());
raf.writeInt(103);
raf.close();
}
public static void writeFile()throws IOException{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.write("李四".getBytes());
raf.writeInt(97);
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
}
运行结果为：
周七
103
从前面的派生图可以看出，RandomAccessFile不算是IO体系中子类，而是直接继承自Object。但是它是IO包中成员，因为它具备读和写功能。
实际上RandomAccessFile内部封装了一个数组，而且通过指针对数组的元素进行操作。
从例子可以看出通过getFilePointer获取指针位置，同时通过seek改变指针的位置。
至于RandomAccessFile能够同时实现读和写的功能的原因，其实是是其在内部封装了字节输入流和输出流。
通过查询API中构造函数可以看出，该类只能操作文件，而且操作文件还有模式：只读r，，读写rw等。
如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。
9.例子九（管道流）：
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
class Read implements Runnable {
private PipedInputStream in;
Read(PipedInputStream in){
this.in = in;
}
public void run() {
try {
byte[] buf = new byte[1024];
System.out.println("读取前。。没有数据阻塞");
int len = in.read(buf);
System.out.println("读到数据。。阻塞结束");
String s= new String(buf,0,len);
System.out.println(s);
in.close();
}
catch (IOException e) {
throw new RuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable {
private PipedOutputStream out;
Write(PipedOutputStream out) {
this.out = out;
}
public void run() {
try {
System.out.println("开始写入数据，等待6秒后。");
Thread.sleep(6000);
out.write("piped lai la".getBytes());
out.close();
}
catch (Exception e) {
throw new RuntimeException("管道输出流失败");
}
}
}
public class PipedStreamDemo {
public static void main(String[] args) throws IOException {
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
// 管道输入流连接到管道输出流。
in.connect(out);
Read r = new Read(in);
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
}
运行结果为：
读取前。。没有数据阻塞
开始写入数据，等待6秒后。
读到数据。。阻塞结束
piped lai la
看完例子，再来看看管道流的特点：
PipedInputStream类与PipedOutputStream类用于在应用程序中创建管道通信，多用于多线程中。
一 个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道。 PipedOutputStream可以向管道中写入数据,PipedIntputStream可以读取PipedOutputStream向管道中写入的数据。
这两个类主要用来完成线程之间的通信。一个线程的PipedInputStream对象能够从另外一个线程的PipedOutputStream对象中读取数据。
所以，我们使用管道流时，必须要同时构造管道输入流和管道输出流。
10.例子十（合并流）：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
public class MergeFile {
public static void main(String[] args) throws IOException {
merge();
}
public static void merge() throws IOException {
// 创建集合，泛型为文件字节输入流。
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=1; x<=3; x++)
// 将输入流添加进集合中。
al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
final Iterator<FileInputStream> it = al.iterator();
// 因为前面为了更加让程序效率使用了ArrayList，所以这里只能通过匿名内部类自定义Enumeration，实现目的。
// 如果前面使用的是Vetor集合，则不需再定义这一步。
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
public boolean hasMoreElements() {
return it.hasNext();
}
public FileInputStream nextElement() {
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)
fos.write(buf,0,len);
fos.close();
sis.close();
}
}
合并流，SequenceInputStream表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。总而言之，合并流就是用来合并多个字节输出流变成一个字节输出流。
11.例子十一（分割文件）：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class SplitFile {
public static void main(String[] args) throws IOException {
splitFile();
}
public static void splitFile()throws IOException {
FileInputStream fis = new FileInputStream("c:\\1.bmp");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1) {
fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
}
可以看出，java中并没有可以直接分割流的对象。分割流的方法很多，以上例子主要是通过计数器，和作为缓冲区的数组来控制分割流，然后输出到不同的文件上。
这十一个例子囊括了IO流中最常用的部分，剩余其他的流的使用思想也是相通的，这里就不再阐述了。相信只要认真的去了解学习IO流，以后它就会成为你的好帮手。
来源：CSDN
作者：丨敲破苍穹灬
链接：https://blog.csdn.net/gzj_vip/article/details/47296085