一、概述
Java的I/O大概可以分为以下几类：
- 磁盘操作：File
- 字节操作：InputStream 和 OutputStream
- 字符操作：Reader 和 Writer
- 对象操作：Serializable
- 网络操作：Socket
- 新的输入/输出：NIO
二、磁盘操作
File 类可以用于表示文件和目录的信息，但是它不表示文件的内容。
递归地输出一个目录下所有文件：
public static void listAllFiles(File dir) {
if (dir == null || !dir.exists()) {
return;
}
if (dir.isFile()) {
System.out.println(dir.getName());
return;
}
for (File file : dir.listFiles()) {
listAllFiles(file);
}
}
三、字节操作
使用字节流操作进行文件复制：
public static void copyFile(String src, String dist) throws IOException {
FileInputStream in = new FileInputStream(src);
FileOutputStream out = new FileOutputStream(dist);
byte[] buffer = new byte[20 * 1024];
// read() 最多读取 buffer.length 个字节
// 返回的是实际读取的个数
// 返回 -1 的时候表示读到 eof，即文件尾
while (in.read(buffer, 0, buffer.length) != -1) {
out.write(buffer);
}
in.close();
out.close();
}
DP-Decorator-java.io.png
Java I/O 使用了装饰者模式来实现。以 InputStream 为例，
- InputStream 是抽象组件；
- FileInputStream是InputStream的子类，属于具体组件，提供了字节流的输入操作；
- FilterInputStream属于抽象装饰者，装饰者用于装饰组件，为组件提供额外的功能，例如BufferedInputStream为 FileInputStream 提供缓存的功能。
实例化一个具有缓存功能的字节流对象时，只需要在FileInputStream 对象上再套一层BufferedInputStream对象即可。
FileInputStream fileInputStream = new FileInputStream(filePath);
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
DataInputStream装饰者提供了对更多数据类型进行输入的操作，比如 int、double 等基本类型。
四、字符操作
不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符。但是在程序中操作的通常是字符形式的数据，因此需要提供对字符进行操作的方法。
- InputStreamReader 实现从字节流解码成字符流；
- OutputStreamWriter 实现字符流编码成为字节流。
逐行输出文本文件的内容：
public static void readFileContent(String filePath) throws IOException {
FileReader fileReader = new FileReader(filePath);
BufferedReader bufferedReader = new BufferedReader(fileReader);
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
// 装饰者模式使得 BufferedReader 组合了一个 Reader 对象
// 在调用 BufferedReader 的 close() 方法时会去调用 fileReader 的 close() 方法
// 因此只要一个 close() 调用即可
bufferedReader.close();
}
五、对象操作
序列化就是将一个对象转换成字节序列，方便存储和传输。
- 序列化：ObjectOutputStream.writeObject()
- 反序列化：ObjectInputStream.readObject()
序列化的类需要实现Serializable接口，它只是一个标准，没有任何方法需要实现，可以理解为标记型接口，但是如果不去实现它的话而进行序列化，会抛出异常。
public static void main(String[] args) throws IOException, ClassNotFoundException {
A a1 = new A(123, "abc");
String objectFile = "file/a1";
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(objectFile));
objectOutputStream.writeObject(a1);
objectOutputStream.close();
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(objectFile));
A a2 = (A) objectInputStream.readObject();
objectInputStream.close();
System.out.println(a2);
}
private static class A implements Serializable {
private int x;
private String y;
A(int x, String y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "x = " + x + " " + "y = " + y;
}
}
不会对静态变量进行序列化，因为序列化只是保存对象的状态，静态变量属于类的状态。
六、网络操作
Java 中的网络支持：
- InetAddress：用于表示网络上的硬件资源，即IP地址；
- URL：统一资源定位符；
- Sockets：使用 TCP 协议实现网络通信；
- Datagram：使用 UDP 协议实现网络通信。
InetAddress
没有公有的构造函数，只能通过静态方法来创建实例。
InetAddress.getByName(String host);
InetAddress.getByAddress(byte[] address);
URL
可以直接从 URL 中读取字节流数据。
public static void main(String[] args) throws IOException {
URL url = new URL("http://www.baidu.com");
/* 字节流 */
InputStream is = url.openStream();
/* 字符流 */
InputStreamReader isr = new InputStreamReader(is, "utf-8");
/* 提供缓存功能 */
BufferedReader br = new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
}
Sockets
- ServerSocket：服务器端类
- Socket：客户端类
-
服务器和客户端通过InputStream和OutputStream进行输入输出。
ClienteServidorSockets1521731145260.jpg
Datagram
- DatagramPacket：数据包类
- DatagramSocket：通信类
七、NIO
新的输入/输出(NIO)库是在JDK1.4中引入的，弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。
流与块
I/O 与 NIO 最重要的区别是数据打包和传输的方式，I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。
面向流的 I/O 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
面向块的 I/O 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。
I/O 包和 NIO 已经很好地集成了，java.io已经以NIO为基础重新实现了，所以现在它可以利用NIO的一些特性。例如，java.io包中的一些类包含以块的形式读写数据的方法，这使得即使在面向流的系统中，处理速度也会更快。
通道与缓冲区
1.通道
通道 Channel 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。
通道与流的不同之处在于，流只能在一个方向上移动(一个流必须是 InputStream或者OutputStream的子类)，而通道是双向的，可以用于读、写或者同时用于读写。
通道包括以下类型：
- FileChannel：从文件中读写数据；
- DatagramChannel：通过 UDP 读写网络中数据；
- SocketChannel：通过 TCP 读写网络中数据；
- ServerSocketChannel：可以监听新进来的TCP连接，对每一个新进来的连接都会创建一个 SocketChannel。
2.缓冲区
发送给一个通道的所有数据都必须首先放到缓冲区中，同样地，从通道中读取的任何数据都要先读到缓冲区中。也就是说，不会直接对通道进行读写数据，而是要先经过缓冲区。
缓冲区实质上是一个数组，但它不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。
缓冲区包括以下类型：
- ByteBuffer
- CharBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- FloatBuffer
- DoubleBuffer
缓冲区状态变量
capacity：最大容量；
position：当前已经读写的字节数；
limit：还可以读写的字节数。
状态变量的改变过程举例：
① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit =capacity=8。capacity变量不会改变，下面的讨论会忽略它。
② 从输入通道中读取5个字节数据写入缓冲区中，此时position 移动设置为 5，limit 保持不变。
③ 在将缓冲区的数据写到输出通道之前，需要先调用flip() 方法，这个方法将limit设置为当前position，并将position 设置为 0。
④ 从缓冲区中取4个字节到输出缓冲中，此时position设为 4。
⑤ 最后需要调用clear()方法来清空缓冲区，此时position 和 limit 都被设置为最初位置。
文件NIO实例
以下展示了使用 NIO 快速复制文件的实例：
public static void fastCopy(String src, String dist) throws IOException {
/* 获得源文件的输入字节流 */
FileInputStream fin = new FileInputStream(src);
/* 获取输入字节流的文件通道 */
FileChannel fcin = fin.getChannel();
/* 获取目标文件的输出字节流 */
FileOutputStream fout = new FileOutputStream(dist);
/* 获取输出字节流的通道 */
FileChannel fcout = fout.getChannel();
/* 为缓冲区分配 1024 个字节 */
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
while (true) {
/* 从输入通道中读取数据到缓冲区中 */
int r = fcin.read(buffer);
/* read() 返回 -1 表示 EOF */
if (r == -1) {
break;
}
/* 切换读写 */
buffer.flip();
/* 把缓冲区的内容写入输出文件中 */
fcout.write(buffer);
/* 清空缓冲区 */
buffer.clear();
}
}
选择器Selector
传统的IO是阻塞的，当服务端与客户端建立连接后服务端会阻塞式的等待客户端的消息，虽然可以用多个线程连接多个客户端，但是线程创建销毁的开销比较大。
NIO采用Selector解决这个问题，Selector类将传入客户机请求多路分用，并将它们分派到各自的请求处理程序，实现对客户端请求事件的非阻塞监听。
Selector允许单线程处理多个Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用Selector就会很方便。
overview-selectors.png
要使用Selector，得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新连接进来，数据接收等。
对比
NIO 与普通 I/O 的区别主要有以下两点：
- NIO 是非阻塞的
- NIO 面向块，I/O 面向流
网友评论