一、简介

Java IO流提供了一种可以对数据进行输入输出的机制。可以把它比作是一条河流从源头流向目标地，由源文件输入到程序再由程序输出到目标文件。

1. 什么是IO流

IO即Input/Output顾名思义就是数据的输入输出，在Java中指的是java.io包中的类库，提供了一系列操作数据输入与输出的类和接口。

2. IO流的分类

Java IO流按照其功能可以分为4种类型：

1. 字节流（Byte Streams）：从字节流中读入或输出8位字节数据。InputStream 和 OutputStream 都是针对字节的流。
2. 字符流（Character Streams）：从字符流中读入或输出16位Unicode字符。Reader 和 Writer 都是针对字符的流。
3. 节点流（Node Streams）：Advanced 系列流，如 FileInputStream、FileOutputStream。
4. 处理流（Filter Streams）：Decorator 系列流，如 BufferedInputStream、BufferedOutputStream、ObjectInputStream、ObjectOutputStream。

3. IO流的作用

在Java中IO流的主要作用是将数据从一个地方传输到另一个地方。我们可以使用Java的IO流来实现从文件、控制台甚至是网络传输数据等功能。对于不同的需求，可以灵活选择不同的IO流类型。

二、Java IO流的输入操作

Java IO流提供了多种输入操作的类和接口下面将分别介绍其中的四种。

1. 文件输入流

用于从文件中读取数据可以使用 java.io.FileInputStream 类来实现。

try {FileInputStream fis = new FileInputStream("file.txt");   // 指定文件路径int c;while ((c = fis.read()) != -1) {    // 从文件中读取数据System.out.print((char)c);     // 输出数据到控制台}fis.close();                        // 关闭文件流
} catch (IOException e) {e.printStackTrace();
}

2. 字节输入流

用于从数据源中读取字节数据可以使用 java.io.InputStream 类来实现。

try {InputStream is = new FileInputStream("file.txt");    // 指定数据源int c;while ((c = is.read()) != -1) {     // 从数据源读取数据System.out.print((char)c);      // 输出数据到控制台}is.close();                         // 关闭数据流
} catch (IOException e) {e.printStackTrace();
}

3. 缓冲输入流

提供了对 IO 字节输入流的缓存机制可以使用 java.io.BufferedInputStream 类来实现

try {InputStream is = new FileInputStream("file.txt");    // 指定数据源BufferedInputStream bis = new BufferedInputStream(is);    // 使用缓冲输入流读取数据int c;while ((c = bis.read()) != -1) {    // 从缓冲输入流中读取数据System.out.print((char)c);      // 输出数据到控制台}is.close();                         // 关闭数据流
} catch (IOException e) {e.printStackTrace();
}

4. 对象输入流

用于读取对象的相关信息可以使用 java.io.ObjectInputStream 类来实现

try {InputStream is = new FileInputStream("file.txt");     // 指定数据源ObjectInputStream ois = new ObjectInputStream(is);     // 使用对象输入流读取对象相关信息Object obj = ois.readObject();      // 从对象输入流中读取对象相关信息并实例化为一个对象System.out.println(obj);            // 输出读取到的对象is.close();                         // 关闭数据流
} catch (IOException | ClassNotFoundException e) {e.printStackTrace();
}

三、Java IO流的输出操作

Java IO流提供了多种输出操作的类和接口，下面将分别介绍其中的四种。

1. 文件输出流

用于向文件中写入数据可以使用 java.io.FileOutputStream 类来实现

try {FileOutputStream fos = new FileOutputStream("file.txt");     // 指定输出文件路径String s = "Hello, World!";         // 要写入文件的内容byte[] bytes = s.getBytes();        // 将要写入的字符串转化为字节数组fos.write(bytes);                   // 向文件中写入字节数据fos.close();                        // 关闭文件流
} catch (IOException e) {e.printStackTrace();
}

2. 字节输出流

用于向数据源中输出字节数据可以使用 java.io.OutputStream 类来实现

try {OutputStream os = new FileOutputStream("file.txt");   // 指定数据源String s = "Hello, World!";         // 要写入数据源的内容byte[] bytes = s.getBytes();        // 将要写入的字符串转化为字节数组os.write(bytes);                    // 向数据源中写入字节数据os.close();                         // 关闭数据流
} catch (IOException e) {e.printStackTrace();
}

3. 缓冲输出流

提供了对 IO 字节输出流的缓存机制可以使用 java.io.BufferedOutputStream 类来实现

try {OutputStream os = new FileOutputStream("file.txt");   // 指定数据源BufferedOutputStream bos = new BufferedOutputStream(os);     // 使用缓冲输出流写入数据源String s = "Hello, World!";         // 要写入数据源的内容byte[] bytes = s.getBytes();        // 将要写入的字符串转化为字节数组bos.write(bytes);                   // 向缓冲输出流中写入字节数据bos.flush();                        // 刷新流数据到文件，清空缓存os.close();                         // 关闭数据流
} catch (IOException e) {e.printStackTrace();
}

4. 对象输出流

用于将对象信息写入输出源可以使用 java.io.ObjectOutputStream 类来实现

try {OutputStream os = new FileOutputStream("file.txt");     // 指定数据源ObjectOutputStream oos = new ObjectOutputStream(os);   // 创建对象输出流Object obj = new Object();          // 要写入数据源的对象oos.writeObject(obj);               // 将对象信息写入输出源oos.flush();                        // 刷新流数据到文件，清空缓存os.close();                         // 关闭数据流
} catch (IOException e) {e.printStackTrace();
}

四、Java IO流的常用方法解析

1. 字节读写操作

1.1 FileInputStream和FileOutputStream

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class ByteStreamExample {public static void main(String[] args) {File inputFile = new File("input.txt");File outputFile = new File("output.txt");try (FileInputStream inputStream = new FileInputStream(inputFile);FileOutputStream outputStream = new FileOutputStream(outputFile)) {byte[] buffer = new byte[1024];int length;while ((length = inputStream.read(buffer)) != -1) {outputStream.write(buffer, 0, length);}} catch (IOException e) {e.printStackTrace();}}
}

以上代码实现了从input.txt文件读取数据并写入到output.txt文件中。

1.2 DataInputStream和DataOutputStream

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class DataStreamExample {public static void main(String[] args) {File inputFile = new File("input.txt");File outputFile = new File("output.txt");try (DataInputStream inputStream = new DataInputStream(new FileInputStream(inputFile));DataOutputStream outputStream = new DataOutputStream(new FileOutputStream(outputFile))) {int intValue = inputStream.readInt();outputStream.writeInt(intValue);boolean boolValue = inputStream.readBoolean();outputStream.writeBoolean(boolValue);String strValue = inputStream.readUTF();outputStream.writeUTF(strValue);} catch (IOException e) {e.printStackTrace();}}
}

以上代码实现了从input.txt文件中读取整型、布尔型和字符串类型数据，然后将这些数据写入到output.txt文件中。

2. 按字符读写操作

2.1 FileReader和FileWriter

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class CharStreamExample {public static void main(String[] args) {File inputFile = new File("input.txt");File outputFile = new File("output.txt");try (FileReader reader = new FileReader(inputFile);FileWriter writer = new FileWriter(outputFile)) {char[] buffer = new char[1024];int length;while ((length = reader.read(buffer)) != -1) {writer.write(buffer, 0, length);}} catch (IOException e) {e.printStackTrace();}}
}

以上代码实现了从input.txt文件读取数据并写入到output.txt文件中。

2.2 BufferedReader和BufferedWriter

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class BufferCharStreamExample {public static void main(String[] args) {try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {String line;while ((line = reader.readLine()) != null) {writer.write(line);writer.newLine();}} catch (IOException e) {e.printStackTrace();}}
}

以上代码实现了从input.txt文件读取数据并写入到output.txt文件中，同时以行的形式进行读写。

3. 随机读写文件操作

3.1 RandomAccessFile

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;public class RandomAccessFileExample {public static void main(String[] args) {File file = new File("file.txt");try (RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw")) {randomAccessFile.writeBytes("Hello World!");randomAccessFile.seek(6);randomAccessFile.writeBytes("Java");} catch (IOException e) {e.printStackTrace();}}
}

以上代码实现了向file.txt文件中写入"Hello World!"，然后从第6个字节开始替换为"Java"。

4. 大文件读写操作

4.1 使用MappedByteBuffer

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;public class LargeFileExample {public static void main(String[] args) {File inputFile = new File("input.txt");File outputFile = new File("output.txt");try (FileInputStream inputStream = new FileInputStream(inputFile);FileOutputStream outputStream = new FileOutputStream(outputFile)) {FileChannel inputChannel = inputStream.getChannel();FileChannel outputChannel = outputStream.getChannel();MappedByteBuffer buffer = inputChannel.map(FileChannel.MapMode.READ_ONLY, 0, inputChannel.size());outputChannel.write(buffer);} catch (IOException e) {e.printStackTrace();}}
}

以上代码实现了将input.txt文件中的数据复制到output.txt文件中，如果读取的文件太大需要使用MappedByteBuffer来减少内存开销。

五、Java NIO模块

1. NIO概述

Java NIO（New IO）是JDK1.4引入的新的IO API，能够以更高效的方式进行文件、网络读写等各种I/O操作。

2. NIO与IO的对比

IO	NIO
面向流	面向缓冲（Buffer）
阻塞IO	非阻塞IO
无	选择器（Selector）

3. NIO模块的核心组件

3.1 Buffer

Buffer是一个对象可以容纳一定数量的数据，并提供了一组方法用于访问这些数据。

3.2 Channel

Channel是用于进行数据读写的对象，它类似于IO流中的“管道”。

3.3 Selector

Selector用于监听多个Channel上的事件（如读、写等），并通过一个线程实现多路复用。

4. NIO模块的使用方式

4.1 读取文件数据

import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;public class NioExample {public static void main(String[] args) {Path path = Paths.get("file.txt");try (FileChannel channel = (FileChannel) Files.newByteChannel(path, EnumSet.of(StandardOpenOption.READ))) {ByteBuffer buffer = ByteBuffer.allocate(1024);while (channel.read(buffer) != -1) {buffer.flip();while (buffer.hasRemaining()) {System.out.print((char) buffer.get());}buffer.clear();}} catch (IOException e) {e.printStackTrace();}}
}

以上代码实现了从file.txt文件中读取数据并输出到控制台。其中FileChannel的read()方法用于读取文件数据，ByteBuffer的flip()方法将缓冲区从写入状态切换到读取状态，clear()方法则用于清空缓冲区。

4.2 写入文件数据

import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;public class NioExample {public static void main(String[] args) {Path path = Paths.get("file.txt");try (FileChannel channel = (FileChannel) Files.newByteChannel(path, EnumSet.of(StandardOpenOption.WRITE))) {ByteBuffer buffer = ByteBuffer.wrap("Hello World!".getBytes());channel.write(buffer);} catch (IOException e) {e.printStackTrace();}}
}

以上代码实现了向file.txt文件中写入数据“Hello World!”。其中FileChannel的write()方法用于写入文件数据，ByteBuffer的wrap()方法用于把字节数组包装成缓冲区。