Java I/O
Java I/O（输入/输出）是Java语言中用于处理数据流的一套丰富而强大的API。Java I/O分为两个主要的包：java.io和java.nio（非阻塞I/O）。以下是一些Java I/O的基本概念和组件：
1. 流的概念
- 流：是字节序列的表示，可以是输入流（读取数据）或输出流（发送数据）。
2. 主要的流类
- InputStream 和 OutputStream：所有输入流的超类和所有输出流的超类。
- Reader 和 Writer：基于字符的输入/输出流的超类，使用字符集进行编码和解码。
3. 字节流
- FileInputStream：从文件中读取字节。
- FileOutputStream：向文件写入字节。
- ByteArrayInputStream 和 ByteArrayOutputStream：内存中的字节数组输入/输出。
4. 字符流
- FileReader 和 FileWriter：从文件读取字符和向文件写入字符。
- CharArrayReader 和 CharArrayWriter：内存中的字符数组输入/输出。
5. 缓冲流
- BufferedInputStream 和 BufferedOutputStream：提供缓冲以提高读写效率。
- BufferedReader 和 BufferedWriter：提供缓冲以提高字符读写效率。
6. 数据流
- DataInputStream：从底层的InputStream中读取数据，并将其转换为Java原始数据类型。
- DataOutputStream：将Java原始数据类型转换为可以由InputStream读取的字节。
7. 对象流
- ObjectInputStream 和 ObjectOutputStream：允许对象的读写。
8. 打印流
- PrintStream 和 PrintWriter：提供方便的打印方法。
9. 随机访问文件
- RandomAccessFile：可以以读、写或二者兼备的模式打开文件，并可以随机访问文件。
10. 管道流
- PipedInputStream 和 PipedOutputStream：允许线程通过管道进行通信。
11. 文件操作
- File：表示文件和目录路径名，提供文件操作方法。
示例代码
以下是使用Java I/O进行文件读写的基本示例：
import java.io.*;
public class IOExample {
public static void main(String[] args) {
String filePath = "example.txt";
// 写入文本到文件
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
writer.write("Hello, Java I/O!");
} catch (IOException e) {
e.printStackTrace();
}
// 从文件读取文本
try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
String line = null;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
注意事项
- 使用
try-with-resources语句自动管理资源，确保Closeable对象在使用后能够正确关闭。 - 捕获并处理
IOException，因为I/O操作可能会引发此类异常。 - 根据需要选择合适的流类型，比如字节流或字符流。
Java I/O是Java SE的核心部分，对于任何需要处理文件或数据流的Java应用程序来说都是必不可少的。
以下是Java I/O中不同类型流的使用示例：
1. 字节流 - FileInputStream 和 FileOutputStream
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamExample {
public static void main(String[] args) {
String fromFile = "source.txt";
String toFile = "destination.txt";
try (FileInputStream fis = new FileInputStream(fromFile);
FileOutputStream fos = new FileOutputStream(toFile)) {
int byteRead;
while ((byteRead = fis.read()) != -1) {
fos.write(byteRead);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
2. 字符流 - FileReader 和 FileWriter
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CharStreamExample {
public static void main(String[] args) {
String fromFile = "source.txt";
String toFile = "destination.txt";
try (FileReader fr = new FileReader(fromFile);
FileWriter fw = new FileWriter(toFile)) {
int charRead;
while ((charRead = fr.read()) != -1) {
fw.write(charRead);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. 缓冲流 - BufferedReader 和 BufferedWriter
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedStreamExample {
public static void main(String[] args) {
String inputFile = "input.txt";
String outputFile = "output.txt";
try (BufferedReader br = new BufferedReader(new FileReader(inputFile));
BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile))) {
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine(); // 写入一个新行
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
4. 数据流 - 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) {
String dataFile = "data.txt";
try (DataOutputStream dos = new DataOutputStream(new FileOutputStream(dataFile))) {
dos.writeInt(123);
dos.writeDouble(45.67);
} catch (IOException e) {
e.printStackTrace();
}
try (DataInputStream dis = new DataInputStream(new FileInputStream(dataFile))) {
int intValue = dis.readInt();
double doubleValue = dis.readDouble();
System.out.println("Int: " + intValue + ", Double: " + doubleValue);
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. 对象流 - ObjectOutputStream 和 ObjectInputStream
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.io.Serializable;
public class ObjectStreamExample {
public static void main(String[] args) {
String objectFile = "object.dat";
MyObject obj = new MyObject("Data", 123);
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(objectFile))) {
oos.writeObject(obj);
} catch (IOException e) {
e.printStackTrace();
}
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(objectFile))) {
MyObject objRead = (MyObject) ois.readObject();
System.out.println("Object read: " + objRead);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
static class MyObject implements Serializable {
private String data;
private int number;
public MyObject(String data, int number) {
this.data = data;
this.number = number;
}
@Override
public String toString() {
return "MyObject{" +
"data='" + data + '\'' +
", number=" + number +
'}';
}
}
}
6. 随机访问文件 - RandomAccessFile
import java.io.RandomAccessFile;
import java.io.IOException;
public class RandomAccessFileExample {
public static void main(String[] args) {
String file = "random.dat";
try (RandomAccessFile raf = new RandomAccessFile(file, "rw")) {
// 写入数据
raf.writeInt(12345);
raf.writeDouble(67.89);
// 移动文件指针到文件开头
raf.seek(0);
// 读取数据
int intValue = raf.readInt();
double doubleValue = raf.readDouble();
System.out.println("Int: " + intValue + ", Double: " + doubleValue);
} catch (IOException e) {
e.printStackTrace();
}
}
}
注意事项
- 所有示例都使用了
try-with-resources语句来自动关闭资源。 - 这些示例中的文件路径、数据类型和数据值仅为示例，你应该根据实际需求进行调整。
- 对于
ObjectOutputStream和ObjectInputStream，对象必须实现Serializable接口。 - 异常处理使用了
e.printStackTrace()，仅用于示例。在实际应用中，你可能需要更精细的异常处理策略。
