目录
Java 输入/输出(I/O)操作
1. Java I/O 类体系结构
2. 文件读写操作
2.1 使用 FileInputStream 和 FileOutputStream 进行字节流读写
2.2 使用 FileReader 和 FileWriter 进行字符流读写
3. 缓冲流的使用
3.1 使用 BufferedReader 和 BufferedWriter
4. 使用 Scanner 和 PrintWriter 进行文件操作
5. 序列化与反序列化
5.1 使用 ObjectOutputStream 和 ObjectInputStream
总结与后续
Java 输入/输出(I/O)操作
在软件开发中,输入/输出(I/O) 操作是非常常见的需求,它涉及到数据的读写与传输。Java 提供了强大的 I/O 类库,使得开发者可以方便地对文件、控制台、网络流等进行读写操作。本模块将介绍 Java 中的 I/O 类体系、文件读写、缓冲流和字符流的使用,帮助你掌握如何处理数据的输入和输出。
1. Java I/O 类体系结构
Java 的 I/O 类库主要包含在 java.io
和 java.nio
包中,提供了一系列用于操作字节流和字符流的类。
-
字节流:用于处理二进制数据,类名以
InputStream
或OutputStream
结尾。 -
字符流:用于处理文本数据,类名以
Reader
或Writer
结尾。
类名 | 描述 |
---|---|
InputStream | 字节输入流的抽象类 |
OutputStream | 字节输出流的抽象类 |
FileInputStream | 从文件中读取字节的输入流 |
FileOutputStream | 向文件中写入字节的输出流 |
Reader | 字符输入流的抽象类 |
Writer | 字符输出流的抽象类 |
FileReader | 从文件中读取字符的输入流 |
FileWriter | 向文件中写入字符的输出流 |
BufferedReader | 带缓冲的字符输入流 |
BufferedWriter | 带缓冲的字符输出流 |
2. 文件读写操作
文件读写是 Java I/O 操作中最常见的应用场景之一。我们可以使用 FileInputStream
和 FileOutputStream
处理字节流,或者使用 FileReader
和 FileWriter
处理字符流。
2.1 使用 FileInputStream
和 FileOutputStream
进行字节流读写
示例:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("input.txt");
FileOutputStream fos = new FileOutputStream("output.txt")) {
int data;
while ((data = fis.read()) != -1) {
fos.write(data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个例子中,我们使用 FileInputStream
从 input.txt
中读取字节,并将它们通过 FileOutputStream
写入到 output.txt
中。
2.2 使用 FileReader
和 FileWriter
进行字符流读写
示例:
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CharStreamExample {
public static void main(String[] args) {
try (FileReader fr = new FileReader("input.txt");
FileWriter fw = new FileWriter("output.txt")) {
int data;
while ((data = fr.read()) != -1) {
fw.write(data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个例子中,我们使用 FileReader
和 FileWriter
来读取和写入字符文件。这种方法适用于处理文本数据。
3. 缓冲流的使用
缓冲流(Buffered Stream)可以提高 I/O 操作的效率。缓冲流通过减少与底层系统的交互次数,显著提升了读写速度。
3.1 使用 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) {
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个例子中,我们使用 BufferedReader
逐行读取文件内容,并使用 BufferedWriter
将内容写入到另一个文件中。readLine()
方法每次读取一整行,newLine()
方法用于写入系统的行分隔符。
4. 使用 Scanner
和 PrintWriter
进行文件操作
Scanner
类可以方便地从文件中读取数据,而 PrintWriter
类则用于将数据格式化输出到文件中。
示例:
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class ScannerPrintWriterExample {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(new File("input.txt"));
PrintWriter writer = new PrintWriter("output.txt")) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
writer.println(line);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
在这个例子中,我们使用 Scanner
逐行读取文件内容,并使用 PrintWriter
将内容写入到另一个文件中。Scanner
和 PrintWriter
提供了方便的方法来处理文本数据的输入和输出。
5. 序列化与反序列化
序列化 是将对象的状态转换为字节流的过程,以便将其保存到文件或通过网络传输。反序列化 是从字节流中恢复对象的过程。
5.1 使用 ObjectOutputStream
和 ObjectInputStream
示例:
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.io.IOException;
class Person implements Serializable {
private static final long serialVersionUID = 1L;
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
public class SerializationExample {
public static void main(String[] args) {
Person person = new Person("Alice", 30);
// 序列化对象
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
oos.writeObject(person);
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
Person deserializedPerson = (Person) ois.readObject();
System.out.println("反序列化后的对象: " + deserializedPerson);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
在这个例子中,Person
类实现了 Serializable
接口,以使对象可以被序列化。我们使用 ObjectOutputStream
将对象保存到文件中,并使用 ObjectInputStream
从文件中读取对象。
总结与后续
在本模块中,我们学习了 Java 中的输入/输出操作,包括文件的读写、缓冲流的使用以及对象的序列化与反序列化。掌握 I/O 操作对于处理文件和数据非常重要,是开发实际应用程序的基础技能。
在下一模块中,我们将深入探讨 Java 网络编程,学习如何通过 Java 实现客户端与服务器之间的