每文一句
每想拥抱你一次，天空飘落一片雪，至此雪花拥抱撒哈拉！ —荷西
一、IO流开篇
1. 概念：
IO（Input/Output）流是Java中用于处理输入和输出数据的机制。它允许程序与外部设备（如文件、网络连接、内存等）进行数据交换。IO流按照操作单位的不同可以分为字节流和字符流两种类型。
2. 流的分类：
字节流（Byte Streams）：以字节为单位进行操作，适用于处理二进制数据或不需要进行字符编码转换的场景。主要的字节流类包括InputStream和OutputStream及其子类。字符流（Character Streams）：以字符为单位进行操作，适用于处理文本数据并支持字符编码转换。主要的字符流类包括Reader和Writer及其子类。
3. IO流的作用：
实现数据的输入和输出：通过IO流，可以从外部源中读取数据到程序中，或者将程序中的数据写入到外部源中。处理文件操作：可以通过IO流读取、写入文件，实现文件的读取、写入和操作。网络通信：通过IO流可以实现网络通信，包括建立Socket连接、传输数据等。
4. IO流的使用场景：
文件操作：读取、写入和处理文件。网络编程：建立Socket连接，进行网络通信。数据处理：通过IO流实现数据的输入、输出和处理，包括序列化、反序列化等操作。图像处理：读取、写入图像文件，并进行图像处理操作。
二、字节流
字节流常用类
字节流是Java中处理字节数据的流，主要用于处理二进制数据或不需要进行字符编码转换的情况。以下是常用的字节流类：
1. InputStream（输入流）及其子类：
FileInputStream：用于从文件中读取数据的输入流。ByteArrayInputStream：从内存中的字节数组中读取数据的输入流。BufferedInputStream：带有缓冲区的输入流，可以提高读取性能。DataInputStream：读取基本数据类型的输入流，例如int、double等。ObjectInputStream：用于反序列化对象的输入流，可以将对象从字节流中恢复为原来的对象。
2. OutputStream（输出流）及其子类：
FileOutputStream：用于向文件中写入数据的输出流。ByteArrayOutputStream：将数据写入到内存中的字节数组的输出流。BufferedOutputStream：带有缓冲区的输出流，可以提高写入性能。DataOutputStream：写入基本数据类型的输出流，例如int、double等。ObjectOutputStream：用于序列化对象的输出流，可以将对象转换为字节流进行持久化存储。
字节流使用案例
1. FileInputStream（文件输入流）：
简单介绍： 用于从文件中读取数据的输入流。应用场景： 读取文件内容，进行数据处理和分析。代码演示：import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("example.txt")) {
int data;
while ((data = fis.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
2. FileOutputStream（文件输出流）：
简单介绍： 用于向文件中写入数据的输出流。应用场景： 将程序中的数据写入文件，如日志记录、数据持久化等。代码演示：import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamExample {
public static void main(String[] args) {
String data = "Hello, FileOutputStream!";
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
fos.write(data.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. ByteArrayInputStream（字节数组输入流）：
简单介绍： 从字节数组中读取数据的输入流。应用场景： 将字节数组作为数据源，进行数据的读取和处理。代码演示：import java.io.ByteArrayInputStream;
import java.io.IOException;
public class ByteArrayInputStreamExample {
public static void main(String[] args) {
byte[] bytes = {72, 101, 108, 108, 111};
try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes)) {
int data;
while ((data = bais.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
4. ByteArrayOutputStream（字节数组输出流）：
简单介绍： 将数据写入到字节数组的输出流。应用场景： 将程序中的数据写入字节数组，便于数据传输和处理。代码演示：import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class ByteArrayOutputStreamExample {
public static void main(String[] args) {
String data = "Hello, ByteArrayOutputStream!";
try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
baos.write(data.getBytes());
byte[] result = baos.toByteArray();
System.out.println(new String(result));
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. BufferedInputStream（缓冲输入流）：
简单介绍： 带有缓冲区的输入流，提高读取性能。应用场景： 从文件中读取大量数据时，通过缓冲区减少IO操作次数，提升读取效率。代码演示：import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class BufferedInputStreamExample {
public static void main(String[] args) {
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("example.txt"))) {
int data;
while ((data = bis.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
6. BufferedOutputStream（缓冲输出流）：
简单介绍： 带有缓冲区的输出流，提高写入性能。应用场景： 向文件中写入大量数据时，通过缓冲区减少IO操作次数，提升写入效率。代码演示：import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedOutputStreamExample {
public static void main(String[] args) {
String data = "Hello, BufferedOutputStream!";
try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
bos.write(data.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
}
7. DataInputStream（数据输入流）：
简单介绍： 读取基本数据类型的数据的输入流。应用场景： 读取通过DataOutputStream写入的基本数据类型数据。代码演示：import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class DataInputStreamExample {
public static void main(String[] args) {
try (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"))) {
int intValue = dis.readInt();
double doubleValue = dis.readDouble();
System.out.println("Int value: " + intValue);
System.out.println("Double value: " + doubleValue);
} catch (IOException e) {
e.printStackTrace();
}
}
}
8. DataOutputStream（数据输出流）：
简单介绍： 将基本数据类型的数据写入文件的输出流。应用场景： 将程序中的基本数据类型数据写入文件，便于持久化存储。代码演示：import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataOutputStreamExample {
public static void main(String[] args) {
try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"))) {
int intValue = 42;
double doubleValue = 3.14;
dos.writeInt(intValue);
dos.writeDouble(doubleValue);
} catch (IOException e) {
e.printStackTrace();
}
}
}
9. ObjectInputStream（对象输入流）：
简单介绍： 用于反序列化对象的输入流，可以将对象从字节流中恢复为原来的对象。应用场景： 用于读取通过 ObjectOutputStream 序列化的对象数据，恢复为原来的对象。代码演示：import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class ObjectInputStreamExample {
public static void main(String[] args) {
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.bin"))) {
// 从文件中读取对象
MyClass obj = (MyClass) ois.readObject();
System.out.println("Object read from file: " + obj);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
10. ObjectOutputStream（对象输出流）：
简单介绍： 用于将对象序列化为字节流并写入文件的输出流，可以将对象持久化存储。应用场景： 用于将程序中的对象数据序列化为字节流，保存到文件中或传输到网络。代码演示：import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamExample {
public static void main(String[] args) {
MyClass obj = new MyClass("John", 30);
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.bin"))) {
// 将对象写入文件
oos.writeObject(obj);
System.out.println("Object written to file: " + obj);
} catch (IOException e) {
e.printStackTrace();
}
}
}
三、字符流
字符流常用类
字符流是Java中处理字符数据的流，主要用于处理文本数据并支持字符编码转换。以下是常用的字符流类：
1. Reader（读取字符流）及其子类：
FileReader：从文件中读取字符数据的字符输入流。BufferedReader：带有缓冲区的字符输入流，提高读取性能。InputStreamReader：将字节流转换为字符流的桥梁，支持指定字符编码。StringReader：从字符串中读取字符数据的字符输入流。
2. Writer（写入字符流）及其子类：
FileWriter：向文件中写入字符数据的字符输出流。BufferedWriter：带有缓冲区的字符输出流，提高写入性能。OutputStreamWriter：将字符流转换为字节流的桥梁，支持指定字符编码。StringWriter：将字符数据写入到字符串中的字符输出流。
字符流使用案例
1. FileReader（文件读取字符流）：
简单介绍： 用于从文件中读取字符数据的字符输入流。应用场景： 读取文本文件中的内容，进行处理或分析。代码演示：import java.io.FileReader;
import java.io.IOException;
public class FileReaderExample {
public static void main(String[] args) {
try (FileReader reader = new FileReader("example.txt")) {
int character;
while ((character = reader.read()) != -1) {
System.out.print((char) character);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
2. FileWriter（文件写入字符流）：
简单介绍： 用于向文件中写入字符数据的字符输出流。应用场景： 将程序中生成的文本数据写入文件，如日志记录等。代码演示：import java.io.FileWriter;
import java.io.IOException;
public class FileWriterExample {
public static void main(String[] args) {
String data = "Hello, FileWriter!";
try (FileWriter writer = new FileWriter("output.txt")) {
writer.write(data);
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. BufferedReader（带缓冲的字符读取流）：
简单介绍： 带有缓冲区的字符输入流，可以提高读取性能。应用场景： 从文件中读取大量字符数据时，通过缓冲区减少IO操作次数，提升读取效率。代码演示：import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderExample {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
4. BufferedWriter（带缓冲的字符写入流）：
简单介绍： 带有缓冲区的字符输出流，可以提高写入性能。应用场景： 向文件中写入大量字符数据时，通过缓冲区减少IO操作次数，提升写入效率。代码演示：import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterExample {
public static void main(String[] args) {
String data = "Hello, BufferedWriter!";
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
writer.write(data);
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. InputStreamReader（字节流到字符流的桥梁）：
简单介绍： 将字节流转换为字符流的桥梁，支持指定字符编码。应用场景： 从字节流中读取字符数据，并根据指定的字符编码转换为字符流。代码演示：import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderExample {
public static void main(String[] args) {
try (InputStreamReader isr = new InputStreamReader(new FileInputStream("example.txt"), "UTF-8")) {
int character;
while ((character = isr.read()) != -1) {
System.out.print((char) character);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
6. OutputStreamWriter（字符流到字节流的桥梁）：
简单介绍： 将字符流转换为字节流的桥梁，支持指定字符编码。应用场景： 将字符数据转换为字节流，并根据指定的字符编码写入到字节流中。代码演示：import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterExample {
public static void main(String[] args) {
String data = "Hello, OutputStreamWriter!";
try (OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("output.txt"), "UTF-8")) {
osw.write(data);
} catch (IOException e) {
e.printStackTrace();
}
}
}
7. StringReader（从字符串读取字符流）：
简单介绍： 从字符串中读取字符数据的字符输入流。应用场景： 将字符串数据作为输入源，进行字符数据的读取和处理。代码演示：import java.io.StringReader;
import java.io.IOException;
public class StringReaderExample {
public static void main(String[] args) {
String data = "Hello, StringReader!";
try (StringReader reader = new StringReader(data)) {
int character;
while ((character = reader.read()) != -1) {
System.out.print((char) character);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
8. StringWriter（写入字符到字符串）：
简单介绍： 将字符数据写入到字符串中的字符输出流。应用场景： 将程序中生成的字符数据写入字符串中，方便后续处理或输出。代码演示：import java.io.StringWriter;
import java.io.IOException;
public class StringWriterExample {
public static void main(String[] args) {
try (StringWriter writer = new StringWriter()) {
String data = "Hello, StringWriter!";
writer.write(data);
System.out.println(writer.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
}
四、完结撒花ING