IO体系

Java IO 体系种类繁多，感觉很复杂，但其实是 IO 涉及的因素太多了。在进行介绍的时候添加了设计模式等的使用，会让你感觉更加难以理解难以使用这些IO类，在此对java的IO做了一个详细的总结。

IO 类设计出来，肯定是为了解决 IO 相关的操作的，想一想哪里会有 IO 操作？网络、磁盘。网络操作相关的类是在 java.net 包下，不在本文的总结范围内。提到磁盘，你可能会想到文件，文件操作在 IO 中是比较典型的操作。在 Java 中引入了 “流” 的概念，它表示任何有能力产生数据源或有能力接收数据源的对象。数据源可以想象成水源，海水、河水、湖水、一杯水等等。数据传输可以想象为水的运输，古代有用桶运水，用竹管运水的，现在有钢管运水，不同的运输方式对应不同的运输特性。

从数据来源或者说是操作对象角度看，IO 类可以分为：

1、文件（file）：FileInputStream、FileOutputStream、FileReader、FileWriter

2、数组（[]）：

  2.1、字节数组（byte[]）：ByteArrayInputStream、ByteArrayOutputStream2.2、字符数组（char[]）：CharArrayReader、CharArrayWriter

3、管道操作：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter

4、基本数据类型：DataInputStream、DataOutputStream

5、缓冲操作：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

6、打印：PrintStream、PrintWriter

7、对象序列化反序列化：ObjectInputStream、ObjectOutputStream

8、转换：InputStreamReader、OutputStreWriter

数据源节点也可以再进行二次处理，使数据更加容易使用，所以还可以划分成节点流和处理流，涉及到设计模式的使用。

从数据传输方式或者说是运输方式角度看，可以将 IO 类分为：

1、字节流
2、字符流

字节流是以一个字节单位来运输的，比如一杯一杯的取水。而字符流是以多个字节来运输的，比如一桶一桶的取水，一桶水又可以分为几杯水。

字节流和字符流的区别：
字节流读取单个字节，字符流读取单个字符（一个字符根据编码的不同，对应的字节也不同，如 UTF-8 编码是 3 个字节，中文编码是 2 个字节。）字节流用来处理二进制文件（图片、MP3、视频文件），字符流用来处理文本文件（可以看做是特殊的二进制文件，使用了某种编码，人可以阅读）。简而言之，字节是个计算机看的，字符才是给人看的。

字节流和字符流的划分可以看下面这张图。

不可否认，Java IO 相关的类确实很多，但我们并不是所有的类都会用到，我们常用的也就是文件相关的几个类，如文件最基本的读写类 File 开头的、文件读写带缓冲区的类 Buffered 开头的类，对象序列化反序列化相关的类 Object 开头的类。

IO类和相关方法

IO 类虽然很多，但最基本的是 4 个抽象类：InputStream、OutputStream、Reader、Writer。最基本的方法也就是一个读 read() 方法、一个写 write() 方法。方法具体的实现还是要看继承这 4 个抽象类的子类，毕竟我们平时使用的也是子类对象。这些类中的一些方法都是（Native）本地方法、所以并没有 Java 源代码，下面我对这些常用类进行了总结。

先来看 InputStream 和 OutStream 中的方法简介，因为都是抽象类、大都是抽象方法、所以就不贴源码喽！注意这里的读取和写入，其实就是获取（输入）数据和输出数据。

InputStream 类

读取数据

public abstract int read()

将读取到的数据放在 byte 数组中，该方法实际上是根据下面的方法实现的，off 为 0，len 为数组的长度

public int read(byte b[])

从第 off 位置读取 len 长度字节的数据放到 byte 数组中，流是以 -1 来判断是否读取结束的（注意这里读取的虽然是一个字节，但是返回的却是 int 类型 4 个字节）

public int read(byte b[], int off, int len)

跳过指定个数的字节不读取，想想看电影跳过片头片尾

public long skip(long n)

返回可读的字节数量

public int available()

读取完，关闭流，释放资源

public void close()

标记读取位置，下次还可以从这里开始读取，使用前要看当前流是否支持，可以使用 markSupport() 方法判断

public synchronized void mark(int readlimit)

重置读取位置为上次 mark 标记的位置

public synchronized void reset()

判断当前流是否支持标记流，和上面两个方法配套使用

public boolean markSupported()

OutputStream 类

写入一个字节，可以看到这里的参数是一个 int 类型，对应上面的读方法，int 类型的 32 位，只有低 8 位才写入，高 24 位将舍弃。

public abstract void write(int b)

将数组中的所有字节写入，和上面对应的 read() 方法类似，实际调用的也是下面的方法。

public void write(byte b[])

将 byte 数组从 off 位置开始，len 长度的字节写入

public void write(byte b[], int off, int len)

强制刷新，将缓冲中的数据写入

public void flush()

关闭输出流，流被关闭后就不能再输出数据了

public void close()

再来看 Reader 和 Writer 类中的方法，你会发现和上面两个抽象基类中的方法很像。

Reader 类

读取字节到字符缓存中

public int read(java.nio.CharBuffer target)

读取单个字符

public int read()

读取字符到指定的 char 数组中

public int read(char cbuf[])

从 off 位置读取 len 长度的字符到 char 数组中

abstract public int read(char cbuf[], int off, int len)

跳过指定长度的字符数量

public long skip(long n)

和上面的 available() 方法类似

public boolean ready()

判断当前流是否支持标记流

public boolean markSupported()

标记读取位置，下次还可以从这里开始读取，使用前要看当前流是否支持，可以使用 markSupport() 方法判断

public void mark(int readAheadLimit)

重置读取位置为上次 mark 标记的位置

public void reset()

关闭流释放相关资源

abstract public void close()

Writer 类

写入一个字符

public void write(int c)

写入一个字符数组

public void write(char cbuf[])

从字符数组的 off 位置写入 len 数量的字符

abstract public void write(char cbuf[], int off, int len)

写入一个字符串

public void write(String str)

从字符串的 off 位置写入 len 数量的字符

public void write(String str, int off, int len)

追加吸入一个字符序列

public Writer append(CharSequence csq)

追加写入一个字符序列的一部分，从 start 位置开始，end 位置结束

public Writer append(CharSequence csq, int start, int end)

追加写入一个 16 位的字符

public Writer append(char c)

强制刷新，将缓冲中的数据写入

abstract public void flush()

关闭输出流，流被关闭后就不能再输出数据了

abstract public void close()

下面我们就直接使用他们的子类，在使用中再介绍下面没有的新方法。

1、读取控制台中的输入

import java.io.*;public class IOTest {public static void main(String[] args) throws IOException {// 三个测试方法
//        test01();
//        test02();test03();}public static void test01() throws IOException {BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));System.out.println("请输入一个字符");char c;c = (char) bufferedReader.read();System.out.println("你输入的字符为"+c);}public static void test02() throws IOException {BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));System.out.println("请输入一个字符，按 q 键结束");char c;do {c = (char) bufferedReader.read();System.out.println("你输入的字符为"+c);} while (c != 'q');}public static void test03() throws IOException {BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));System.out.println("请输入一行字符");String str = bufferedReader.readLine();System.out.println("你输入的字符为" + str);}
}

至于控制台的输出，我们其实一直都在使用呢，System.out.println() ，out 其实是 PrintStream 类对象的引用，PrintStream 类中当然也有 write() 方法，但是我们更常用 print() 方法和 println() 方法，因为这两个方法可以输出的内容种类更多，比如一个打印一个对象，实际调用的对象的 toString() 方法。

2、二进制文件的写入和读取
注意这里文件的路径，可以根据自己情况改一下，虽然这里的文件后缀是txt，但该文件却是一个二进制文件，并不能直接查看。

@Testpublic void test04() throws IOException {byte[] bytes = {10,25,37,12,23};FileOutputStream fileOutputStream = new FileOutputStream(new File("").getAbsolutePath()+"/io/test.txt");// 写入二进制文件，直接打开会出现乱码fileOutputStream.write(bytes);fileOutputStream.close();}@Testpublic void test05() throws IOException {FileInputStream fileInputStream = new FileInputStream(new File("").getAbsolutePath()+"/io/test.txt");int c;// 读取写入的二进制文件，输出字节数组while ((c = fileInputStream.read()) != -1) {System.out.print(c);}}

3、文本文件的写入和读取
write() 方法和 append() 方法并不是像方法名那样，一个是覆盖内容，一个是追加内容，append() 内部也是 write() 方法实现的，也非说区别，也就是 append() 方法可以直接写 null，而 write() 方法需要把 null 当成一个字符串写入，所以两者并无本质的区别。需要注意的是这里并没有指定文件编码，可能会出现乱码的问题。

@Testpublic void test06() throws IOException {FileWriter fileWriter = new FileWriter(new File("").getAbsolutePath()+"/io/test.txt");fileWriter.write("Hello，world！\n欢迎进入Java IO\n");fileWriter.write("不会覆盖文件原本的内容\n");
//        fileWriter.write(null); 不能直接写入 nullfileWriter.append("并不是追加一行内容，不要被方法名迷惑\n");fileWriter.append(null);fileWriter.flush();System.out.println("文件的默认编码为" + fileWriter.getEncoding());fileWriter.close();}@Testpublic void test07() throws IOException {FileWriter fileWriter = new FileWriter(new File("").getAbsolutePath()+"/io/test.txt", false); // 关闭追加模式，变为覆盖模式fileWriter.write("Hello，world！欢迎进入Java IO\n");fileWriter.write("我来覆盖文件原本的内容");fileWriter.append("我是下一行");fileWriter.flush();System.out.println("文件的默认编码为" + fileWriter.getEncoding());fileWriter.close();}@Testpublic void test08() throws IOException {FileReader fileReader = new FileReader(new File("").getAbsolutePath()+"/io/test.txt");BufferedReader bufferedReader = new BufferedReader(fileReader);String str;while ((str = bufferedReader.readLine()) != null) {System.out.println(str);}fileReader.close();bufferedReader.close();}@Testpublic void test09() throws IOException {FileReader fileReader = new FileReader(new File("").getAbsolutePath()+"/io/test.txt");int c;while ((c = fileReader.read()) != -1) {System.out.print((char) c);}}

使用字节流和字符流的转换类 InputStreamReader 和 OutputStreamWriter 可以指定文件的编码，使用 Buffer 相关的类来读取文件的每一行。

@Testpublic void test10() throws IOException {FileOutputStream fileOutputStream = new FileOutputStream(new File("").getAbsolutePath()+"/io/test2.txt");OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "GBK"); // 使用 GBK 编码文件outputStreamWriter.write("Hello，world！\n欢迎进入Java IO\n");outputStreamWriter.append("另外一行内容");outputStreamWriter.flush();System.out.println("文件的编码为" + outputStreamWriter.getEncoding());outputStreamWriter.close();fileOutputStream.close();}@Testpublic void test11() throws IOException {FileInputStream fileInputStream = new FileInputStream(new File("").getAbsolutePath()+"/io/test2.txt");InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "GBK"); // 使用 GBK 解码文件BufferedReader bufferedReader = new BufferedReader(inputStreamReader);String str;while ((str = bufferedReader.readLine()) != null) {System.out.println(str);}bufferedReader.close();inputStreamReader.close();}

4、复制文件
我进行了一些测试，不使用缓冲对文件复制时间的影响，文件的复制实质还是文件的读写。缓冲流是处理流，是对节点流的装饰。

@Testpublic void  test12() throws IOException {// 输入和输出都使用缓冲流FileInputStream in = new FileInputStream("D:\\我的资料\\大数据可视化\\大数据.mp4");BufferedInputStream inBuffer = new BufferedInputStream(in);FileOutputStream out = new FileOutputStream("大数据.mp4");BufferedOutputStream outBuffer = new BufferedOutputStream(out);int len = 0;byte[] bs = new byte[1024];long begin = System.currentTimeMillis();while ((len = inBuffer.read(bs)) != -1) {outBuffer.write(bs, 0, len);}System.out.println("复制文件所需的时间：" + (System.currentTimeMillis() - begin)); // 平均时间约 200 多毫秒inBuffer.close();in.close();outBuffer.close();out.close();}@Testpublic void  test13() throws IOException {// 只有输入使用缓冲流FileInputStream in = new FileInputStream("D:\\我的资料\\大数据可视化\\大数据.mp4");BufferedInputStream inBuffer = new BufferedInputStream(in);FileOutputStream out = new FileOutputStream("大数据.mp4");int len = 0;byte[] bs = new byte[1024];long begin = System.currentTimeMillis();while ((len = inBuffer.read(bs)) != -1) {out.write(bs, 0, len);}System.out.println("复制文件所需时间：" + (System.currentTimeMillis() - begin)); // 平均时间约 500 多毫秒inBuffer.close();in.close();out.close();}@Testpublic void test14() throws IOException {// 输入和输出都不使用缓冲流FileInputStream in = new FileInputStream("D:\\我的资料\\大数据可视化\\大数据.mp4");FileOutputStream out = new FileOutputStream("大数据.mp4");int len = 0;byte[] bs = new byte[1024];long begin = System.currentTimeMillis();while ((len = in.read(bs)) != -1) {out.write(bs, 0, len);}System.out.println("复制文件所需时间：" + (System.currentTimeMillis() - begin)); // 平均时间 700 多毫秒in.close();out.close();}@Testpublic void test15() throws IOException {// 不使用缓冲FileInputStream in = new FileInputStream("D:\\我的资料\\大数据可视化\\大数据.mp4");FileOutputStream out = new FileOutputStream("大数据.mp4");int len = 0;long begin = System.currentTimeMillis();while ((len = in.read()) != -1) {out.write(len);}System.out.println("复制文件所需时间：" + (System.currentTimeMillis() - begin)); // 平均时间约 160000 毫秒，约 2 分多钟in.close();out.close();}

结论：Java IO 类很多，但是把握住整个体系，掌握关键的方法，学习起来就会轻松很多，看完这篇文章，你是否觉得 Java IO 并没有你想的那么难呢？