概述
Java 的 I/O 操作类在包 java.io 下，大概有将近 80 个类，但是这些类大概可以分成四组，分别是：
按处理数据类型来分：字节流和字符流：
- 基于字节操作的 I/O 接口：InputStream 和 OutputStream
- 基于字符操作的 I/O 接口：Writer 和 Reader
按传输数据的方式：磁盘操作和网络操作
- 基于磁盘操作的 I/O 接口：File
- 基于网络操作的 I/O 接口：Socket
按流的方向来分：输入流和输入流
- 要读的话就用输入流，要写的话，就用输出流
前两组主要是根据传输数据的数据格式，后两组主要是根据传输数据的方式，虽然 Socket 类并不在 java.io 包下，但是我仍然把它们划分在一起，因为我个人认为 I/O 的核心问题要么是数据格式影响 I/O 操作，要么是传输方式影响 I/O 操作，也就是将什么样的数据写到什么地方的问题，I/O 只是人与机器或者机器与机器交互的手段，除了在它们能够完成这个交互功能外，我们关注的就是如何提高它的运行效率了，而数据格式和传输方式是影响效率最关键的因素了。
3.什么时候使用字节流？什么时候使用字符流？
首先需要知道的是，任何数据存在硬盘上时，都是以二进制的形式存储的。而通过使用字节流，可以读取任意文件。字节流一次读取一个字节，而字符流使用了字节流读到一个或者多个字节时，去查找指定的编码表，返回对应的编码。所以字符流只能处理纯文本字符数据，而字节流可以处理更多类型的数据，比如图片，视频，音频文件等。因此，只要是纯文本数据处理，优先考虑使用字符流。其他情况就使用字节流。
基于字节的 I/O 操作接口
概述
基于字节的 I/O 操作接口输入和输出分别是：InputStream 和 OutputStream，InputStream 输入流的类继承层次如下图所示：
图 1. InputStream 相关类层次结构（查看大图）
输入流根据数据类型和操作方式又被划分成若干个子类，每个子类分别处理不同操作类型，OutputStream 输出流的类层次结构也是类似，如下图所示：
图 2. OutputStream 相关类层次结构（查看大图）
示例1：使用字节流，读取和存储图片
首先使用输入流读取图片信息，然后通过输出流写入图片信息：
package org.example.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class TestIOStream {
/**
*
* DOC 将F盘下的test.jpg文件，读取后，再存到E盘下面.
*
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
FileInputStream in = new FileInputStream(new File("F:\\test.jpg"));// 指定要读取的图片
File file = new File("E:\\test.jpg");
if (!file.exists()) {// 如果文件不存在，则创建该文件
file.createNewFile();
}
FileOutputStream out = new FileOutputStream(new File("E:\\test.jpg"));// 指定要写入的图片
int n = 0;// 每次读取的字节长度
byte[] bb = new byte[1024];// 存储每次读取的内容
while ((n = in.read(bb)) != -1) {
out.write(bb, 0, n);// 将读取的内容，写入到输出流当中
}
out.close();// 关闭输入输出流
in.close();
}
} 示例2: 使用BufferedInputStream和BufferedOuputStream读写图片
使用方式和FileInputStrem和FileOutputStream基本一致：
package org.example.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class TestBufferedString {
public static void main(String[] args) throws Exception {
// 指定要读取文件的缓冲输入字节流
BufferedInputStream in = new BufferedInputStream(new FileInputStream("F:\\test.jpg"));
File file = new File("E:\\test.jpg");
if (file != null) {
file.createNewFile();
}
// 指定要写入文件的缓冲输出字节流
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));
byte[] bb = new byte[1024];// 用来存储每次读取到的字节数组
int n;// 每次读取到的字节数组的长度
while ((n = in.read(bb)) != -1) {
out.write(bb, 0, n);// 写入到输出流
}
out.close();// 关闭流
in.close();
}
} 基于字符的 I/O 操作接口
概述
不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符，所以 I/O 操作的都是字节而不是字符，但是为啥有操作字符的 I/O 接口呢？这是因为我们的程序中通常操作的数据都是以字符形式，为了操作方便当然要提供一个直接写字符的 I/O 接口，如此而已。我们知道字符到字节必须要经过编码转换，而这个编码又非常耗时，而且还会经常出现乱码问题，所以 I/O 的编码问题经常是让人头疼的问题。关于 I/O 编码问题请参考另一篇文章 《深入分析Java中的中文编码问题。
读字符的操作接口中也是 int read(char cbuf[], int off, int len)，返回读到的 n 个字节数，不管是 Writer 还是 Reader 类它们都只定义了读取或写入的数据字符的方式，也就是怎么写或读，但是并没有规定数据要写到哪去，写到哪去就是我们后面要讨论的基于磁盘和网络的工作机制
图 3.Reader 类层次结构（查看大图）
下图是写字符的 I/O 操作接口涉及到的类，Writer 类提供了一个抽象方法 write(char cbuf[], int off, int len) 由子类去实现。
图 4. Writer 相关类层次结构（查看大图）
示例1：使用字符流，读取和存储纯文本文件
存储文件，也就是像一个文件里写内容，既然是写，那就需要使用输出流。而且我们写的是纯文本文件，所以这里使用字符流来操作，java api提供给我们FileWriter这么一个类，我们来试试：(读取文件同理使用FileReader类)
package org.example.io;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class TestFileWriter {
public static void main(String[] args) throws Exception {
writeToFile();
readFromFile();
}
/**
* DOC 从文件里读取数据.
*
* @throws FileNotFoundException
* @throws IOException
*/
private static void readFromFile() throws FileNotFoundException, IOException {
File file = new File("E:\\helloworld.txt");// 指定要读取的文件
FileReader reader = new FileReader(file);// 获取该文件的输入流
char[] bb = new char[1024];// 用来保存每次读取到的字符
String str = "";// 用来将每次读取到的字符拼接，当然使用StringBuffer类更好
int n;// 每次读取到的字符长度
while ((n = reader.read(bb)) != -1) {
str += new String(bb, 0, n);
}
reader.close();// 关闭输入流，释放连接
System.out.println(str);
}
/**
* DOC 往文件里写入数据.
*
* @throws IOException
*/
private static void writeToFile() throws IOException {
String writerContent = "hello world,你好世界";// 要写入的文本
File file = new File("E:\\helloworld.txt");// 要写入的文本文件
if (!file.exists()) {// 如果文件不存在，则创建该文件
file.createNewFile();
}
FileWriter writer = new FileWriter(file);// 获取该文件的输出流
writer.write(writerContent);// 写内容
writer.flush();// 清空缓冲区，立即将输出流里的内容写到文件里
writer.close();// 关闭输出流，施放资源
}
}
测试结果：
hello world,你好世界
示例2: 通过BufferedReader和BufferedWriter来读写文件
package org.example.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class TestBufferedWriter {
public static void main(String[] args) throws Exception {
write();
read();
}
/**
* DOC 读取信息.
*
* @throws FileNotFoundException
* @throws IOException
*/
private static void read() throws FileNotFoundException, IOException {
File file = new File("E:\\a.txt");// 指定要读取的文件
// 获得该文件的缓冲输入流
BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
String line = "";// 用来保存每次读取一行的内容
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
bufferedReader.close();// 关闭输入流
}
/**
* DOC 写入信息.
*
* @throws IOException
*/
private static void write() throws IOException {
File file = new File("E:\\a.txt");// 指定要写入的文件
if (!file.exists()) {// 如果文件不存在则创建
file.createNewFile();
}
// 获取该文件的缓冲输出流
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
// 写入信息
bufferedWriter.write("你好世界");
bufferedWriter.newLine();// 表示换行
bufferedWriter.write("hello world");
bufferedWriter.flush();// 清空缓冲区
bufferedWriter.close();// 关闭输出流
}
} 字节与字符的转化接口
概述
另外数据持久化或网络传输都是以字节进行的，所以必须要有字符到字节或字节到字符的转化。字符到字节需要转化，其中读的转化过程如下图所示：
InputStreamReader 类是字节到字符的转化桥梁，InputStream 到 Reader 的过程要指定编码字符集，否则将采用操作系统默认字符集，很可能会出现乱码问题。StreamDecoder 正是完成字节到字符的解码的实现类。也就是当你用如下方式读取一个文件时：
try {
StringBuffer str = new StringBuffer();
char[] buf = new char[1024];
FileReader f = new FileReader("file");
while(f.read(buf)>0){
str.append(buf);
}
str.toString();
} catch (IOException e) {}FileReader 类就是按照上面的工作方式读取文件的，FileReader 是继承了 InputStreamReader 类，实际上是读取文件流，然后通过 StreamDecoder 解码成 char，只不过这里的解码字符集是默认字符集。
写入也是类似的过程如下图所示：
通过 OutputStreamWriter 类完成，字符到字节的编码过程，由 StreamEncoder 完成编码过程。
示例：使用转换流InputStreamReader和OutputStreamWriter
当字节流和字符流之间需要转化的时候，或者要对字节数据进行编码转换的时候，就需要使用转换流
package org.example.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class TestStreamReader {
public static void main(String[] args) throws Exception {
File file = new File("E:\\b.txt");
if (!file.exists()) {
file.createNewFile();
}
OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(file), "GBK");
out.write("hello world,你好世界");
out.close();
InputStreamReader in = new InputStreamReader(new FileInputStream(file), "gbk");
char[] cc = new char[1024];
int n = 0;
String str = "";
while ((n = in.read(cc)) != -1) {
str += new String(cc, 0, n);
}
in.close();
System.out.println(str);
}
} 参考
深入分析 Java I/O 的工作机制：
https://www.ibm.com/developerworks/cn/java/j-lo-javaio/
深入分析 Java 中的中文编码问题
http://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/
java IO流
http://blog.csdn.net/a107494639/article/details/7586365