文章目录
- 1. 传统IO模型
- 字节流
- 字符流
- 2. NIO模型
Java中的IO（输入输出）是用于在程序中读取和写入数据的一种机制。Java提供了两种不同的IO模型：传统的IO模型和NIO（New IO）模型。
1. 传统IO模型
在传统的IO模型中，输入和输出是通过字节流或字符流进行处理的。字节流是以8位字节为单位读写数据，而字符流则是以16位字符为单位读写数据。常见的字节流包括InputStream和OutputStream，而常见的字符流包括Reader和Writer。
另外，在传统的IO模型中，还有缓冲流，它们可以提高IO的效率。BufferedInputStream和BufferedOutputStream是字节流的缓冲流，而BufferedReader和BufferedWriter则是字符流的缓冲流。
传统IO模型的优点在于它简单易用，而缺点则是它的效率较低，特别是在处理大量数据时。
以下是一个简单的使用传统IO模型进行文件读写的Java代码示例：
import java.io.*;
public class TraditionalIOExample {
public static void main(String[] args) {
File inputFile = new File("input.txt");
File outputFile = new File("output.txt");
try {
// 使用字节流读取文件
FileInputStream fis = new FileInputStream(inputFile);
// 使用字节流写入文件
FileOutputStream fos = new FileOutputStream(outputFile);
// 使用缓冲流提高效率
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
// 读取数据并写入文件
int len;
byte[] buffer = new byte[1024];
while ((len = bis.read(buffer)) != -1) {
bos.write(buffer, 0, len);
}
// 关闭流
bos.close();
bis.close();
fos.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个例子中，我们首先创建了一个File对象，指定了输入文件和输出文件。然后使用FileInputStream和FileOutputStream来创建字节流，对文件进行读写操作。为了提高效率，我们还使用了缓冲流BufferedInputStream和BufferedOutputStream，将其包装在字节流之上。
接下来，在while循环中，我们不断从输入文件中读取数据，并将其写入到输出文件中。最后，我们关闭所有的流以释放资源。如果在读写过程中发生异常，我们就在catch块中捕获并打印异常信息。
这是一个简单的使用传统IO模型进行文件读写的例子，但实际上，传统IO模型还可以用于网络编程、对象序列化等方面。
字节流
字节流是Java IO中的一种流，它以字节为单位进行读写操作，用于处理二进制数据，如图像、音频等。字节流主要有两种类型：InputStream和OutputStream，分别用于从输入流中读取字节和向输出流中写入字节。
InputStream是所有字节输入流的超类，它定义了读取字节的基本方法，如read()、read(byte[] b)、read(byte[] b, int off, int len)等。其中，read()方法每次读取一个字节，返回一个整数表示实际读取的字节数，如果已经读到流的末尾，则返回-1。read(byte[] b)方法会尝试从输入流中读取b.length个字节，并将其存储在字节数组b中，返回值为实际读取的字节数。read(byte[] b, int off, int len)方法与read(byte[] b)类似，只不过指定了起始偏移量off和读取长度len。
OutputStream是所有字节输出流的超类，它定义了写入字节的基本方法，如write(int b)、write(byte[] b)、write(byte[] b, int off, int len)等。其中，write(int b)方法会将指定的字节写入输出流，write(byte[] b)方法会将字节数组b中的所有字节写入输出流，write(byte[] b, int off, int len)方法则只写入数组b中从偏移量off开始的len个字节。
除了基本的读写方法，字节流还提供了一些其他的常用方法。例如，InputStream中的available()方法返回可以从输入流中读取的估计字节数，mark(int readlimit)方法在输入流中标记当前位置，reset()方法将输入流重新定位到最后一次标记的位置，skip(long n)方法跳过指定的字节数等。而OutputStream中也有类似的方法，如flush()方法将输出流缓冲区的内容强制刷新到目标设备上，close()方法关闭流等。
下面是一个简单的示例代码，演示如何使用字节流进行文件读写操作：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo {
public static void main(String[] args) throws IOException {
// 从文件中读取数据，写入到另一个文件中
FileInputStream fis = new FileInputStream("source.bin");
FileOutputStream fos = new FileOutputStream("dest.bin");
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
fis.close();
fos.close();
}
}
上述代码通过创建FileInputStream和FileOutputStream来实现文件的读写操作，使用read()方法从源文件中读取字节，并使用write()方法将字节写入目标文件中。注意，在使用完流之后，需要及时调用close()方法关闭流。
字符流
字符流是Java IO中的一种流，它以字符为单位进行读写操作，用于处理文本数据，如文本文件、XML等。Java字符流主要有两种类型：Reader和Writer，分别用于从输入流中读取字符和向输出流中写入字符。
Reader是所有字符输入流的超类，它定义了读取字符的基本方法，如read()、read(char[] cbuf)、read(char[] cbuf, int off, int len)等。其中，read()方法每次读取一个字符，返回一个整数表示实际读取的字符数，如果已经读到末尾，则返回-1；read(char[] cbuf)方法会尝试从输入流中读取cbuf.length个字符，并将其存储在字符数组cbuf中，返回值为实际读取的字符数；read(char[] cbuf, int off, int len)方法与read(char[] cbuf)类似，只不过指定了起始偏移量off和读取长度len。
Writer是所有字符输出流的超类，它定义了写入字符的基本方法，如write(int c)、write(char[] cbuf)、write(String str)等。其中，write(int c)方法会将指定的字符写入输出流；write(char[] cbuf)方法会将字符数组cbuf中的所有字符写入输出流；write(String str)方法会将字符串str中的所有字符写入输出流。
除了基本的读写方法，字符流也提供了一些其他的常用方法。例如，Reader中的skip(long n)方法跳过n个字符，mark(int readAheadLimit)方法在输入流中标记当前位置，reset()方法将输入流重新定位到最后一次标记的位置等；而Writer中的flush()方法将输出流缓冲区的内容强制刷新到目标设备上，close()方法关闭流等。
下面是一个简单的示例代码，演示如何使用字符流进行文件读写操作：
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CharacterStreamDemo {
public static void main(String[] args) throws IOException {
// 从文件中读取数据，写入到另一个文件中
FileReader fr = new FileReader("source.txt");
FileWriter fw = new FileWriter("dest.txt");
char[] buffer = new char[1024];
int len;
while ((len = fr.read(buffer)) != -1) {
fw.write(buffer, 0, len);
}
fr.close();
fw.close();
}
}
上述代码通过创建FileReader和FileWriter来实现文件的读写操作，使用read()方法从源文件中读取字符，并使用write()方法将字符写入目标文件中。注意，在使用完流之后，需要及时调用close()方法关闭流。
2. NIO模型
NIO是Java 1.4引入的新IO模型，它的目标是提高IO的效率，特别是在处理大量数据时。NIO的设计中引入了三个重要的概念：通道、缓冲区和选择器。
通道是NIO中的抽象概念，它类似于传统IO模型中的流。但是，通道可以同时进行读写操作，并且可以使用选择器来实现多路复用，从而提高效率。
缓冲区是NIO中的另一个重要概念，它用于存储读取或写入的数据。与传统IO模型不同的是，NIO中的缓冲区可以直接与通道交互，从而避免了频繁地进行字节或字符的拷贝操作，提高了效率。
选择器是NIO中的另一个重要概念，它可以监听多个通道上的事件并在有事件发生时及时地处理它们。这样，一个线程就可以同时处理多个通道上的IO操作，从而避免了线程阻塞等问题，提高了系统的效率和可扩展性。
下面是一个基于NIO模型的简单示例代码：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class NioServer {
private Selector selector;
public void init() throws IOException {
// 创建一个选择器
selector = Selector.open();
// 创建一个ServerSocketChannel并绑定到指定端口
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(8888));
serverSocketChannel.configureBlocking(false);
// 将ServerSocketChannel注册到选择器上，监听ACCEPT事件
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
}
public void start() throws IOException {
while (true) {
// 阻塞等待就绪的Channel
selector.select();
// 获取所有已就绪的Channel
Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key.isAcceptable()) {
// 处理连接请求
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
SocketChannel socketChannel = serverSocketChannel.accept();
socketChannel.configureBlocking(false);
System.out.println("接受新的连接：" + socketChannel.getRemoteAddress());
// 将新连接的SocketChannel注册到选择器上，监听READ事件
socketChannel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
// 处理读取数据
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int readBytes = socketChannel.read(buffer);
if (readBytes > 0) {
buffer.flip();
byte[] bytes = new byte[buffer.remaining()];
buffer.get(bytes);
String content = new String(bytes, "UTF-8");
System.out.println("接收到客户端消息：" + content);
// 回写数据
buffer.clear();
buffer.put("Hello client!".getBytes());
buffer.flip();
socketChannel.write(buffer);
} else if (readBytes < 0) {
// 连接关闭
key.cancel();
socketChannel.close();
}
}
// 移除当前已处理的事件
keyIterator.remove();
}
}
}
public static void main(String[] args) throws IOException {
NioServer server = new NioServer();
server.init();
server.start();
}
}
上述代码中，首先创建了一个选择器（Selector）对象。然后创建了一个ServerSocketChannel并将其注册到选择器上，监听ACCEPT事件。接着进入主循环，调用select()方法阻塞等待就绪的Channel，然后使用selectedKeys()方法获取所有已就绪的Channel，遍历每个已就绪的Channel，根据其状态进行相应的处理。如果是新连接请求，就接受连接并将新的SocketChannel注册到选择器上，监听READ事件；如果是数据读取请求，就读取数据并回写数据。
需要注意的是，在NIO模型中，数据的读写操作是通过缓冲区（Buffer）对象完成的，所以需要在代码中使用ByteBuffer等缓冲区对象来处理数据。另外，NIO模型还需要特别注意内存泄漏的问题，因为它很容易发生，需要及时释放资源和取消注册。
总的来说，NIO比传统的IO模型更适合处理大量数据时的IO操作，并且具有更好的效率和可扩展性。但是，NIO的学习曲线相对较陡峭，需要掌握一定的底层知识和技能。
