IO-Streams in Java

Inhaltsverzeichnis

Vorwort

1. Byte-Streams:

1.1 Eingabebyte-Stream:

1.2 Ausgabe-Byte-Stream:

2. Charakter-Streams:

2.1 Eingabezeichenstrom:

2.2 Ausgabezeichenstrom:

3. Konvertierungsstrom (Konvertierungsstrom wird verwendet, um Bytestrom und Zeichenstrom zu verbinden):

4. Objektfluss:

meine anderen Blogs

Vorwort

In Java ist ein I/O-Stream (Eingabe/Ausgabe) ein Mechanismus zur Verarbeitung von Eingabe- und Ausgabevorgängen. Die E/A-Streams von Java sind hauptsächlich in zwei Kategorien unterteilt: Byte-Streams und Zeichen-Streams. Jede Kategorie ist in Eingabestreams und Ausgabestreams unterteilt.

1. Byte-Streams:

Byteströme führen Lese- und Schreibvorgänge in Bytes durch und eignen sich zur Verarbeitung binärer Daten (wie Bilder, Audio usw.).

1.1 Eingabebyte-Stream:

InputStream (abstrakte Basisklasse für Eingabestreams):

FileInputStream: Bytes aus Datei lesen.

FileInputStream fis = new FileInputStream("example.txt");
int data = fis.read();
while (data != -1) {
    // 处理读取的字节数据
    System.out.print((char) data);
    data = fis.read();
}
fis.close();

ByteArrayInputStream: Bytes aus einem Byte-Array lesen.

byte[] byteArray = {65, 66, 67, 68, 69}; // ASCII values for A, B, C, D, E
ByteArrayInputStream bais = new ByteArrayInputStream(byteArray);
int data = bais.read();
while (data != -1) {
    // 处理读取的字节数据
    System.out.print((char) data);
    data = bais.read();
}
bais.close();

BufferedInputStream: Bietet eine Pufferfunktion zur Verbesserung der Leseeffizienz.

FileInputStream fis = new FileInputStream("example.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
int data = bis.read();
while (data != -1) {
    // 处理读取的字节数据
    System.out.print((char) data);
    data = bis.read();
}
bis.close();

1.2 Ausgabe-Byte-Stream:

OutputStream (abstrakte Basisklasse für Ausgabestreams):

FileOutputStream: Bytes in eine Datei schreiben.

FileOutputStream fos = new FileOutputStream("output.txt");
fos.write("Hello, World!".getBytes());
fos.close();

ByteArrayOutputStream: Bytes in ein Byte-Array schreiben.

ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write("Hello, World!".getBytes());
byte[] result = baos.toByteArray();
baos.close();

BufferedOutputStream: Bietet Pufferfunktion zur Verbesserung der Schreibeffizienz.

FileOutputStream fos = new FileOutputStream("output.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("Hello, World!".getBytes());
bos.close();

2. Charakter-Streams:

Zeichenströme führen Lese- und Schreibvorgänge in Zeicheneinheiten durch und eignen sich zur Verarbeitung von Textdaten.

2.1 Eingabezeichenstrom:

Reader (abstrakte Basisklasse für Eingabestreams):

FileReader: Zeichen aus Datei lesen.

FileReader fr = new FileReader("example.txt");
int data = fr.read();
while (data != -1) {
    // 处理读取的字符数据
    System.out.print((char) data);
    data = fr.read();
}
fr.close();

CharArrayReader: Zeichen aus dem Zeichenarray lesen.

char[] charArray = {'A', 'B', 'C', 'D', 'E'};
CharArrayReader car = new CharArrayReader(charArray);
int data = car.read();
while (data != -1) {
    // 处理读取的字符数据
    System.out.print((char) data);
    data = car.read();
}
car.close();

BufferedReader: Bietet eine Pufferfunktion zur Verbesserung der Leseeffizienz.

FileReader fr = new FileReader("example.txt");
BufferedReader br = new BufferedReader(fr);
String line = br.readLine();
while (line != null) {
    // 处理读取的一行字符数据
    System.out.println(line);
    line = br.readLine();
}
br.close();

2.2 Ausgabezeichenstrom:

Writer (abstrakte Basisklasse für Ausgabestreams):

FileWriter: Zeichen in die Datei schreiben.

FileWriter fw = new FileWriter("output.txt");
fw.write("Hello, World!");
fw.close();

CharArrayWriter: Zeichen in ein Zeichenarray schreiben.

CharArrayWriter caw = new CharArrayWriter();
caw.write("Hello, World!");
char[] result = caw.toCharArray();
caw.close();

BufferedWriter: Bietet Pufferfunktion zur Verbesserung der Schreibeffizienz.

FileWriter fw = new FileWriter("output.txt");
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Hello, World!");
bw.close();

3. Konvertierungsstrom (Konvertierungsstrom wird verwendet, um Bytestrom und Zeichenstrom zu verbinden):

InputStreamReader: Konvertiert einen Byte-Eingabestream in einen Zeichen-Eingabestream.

FileInputStream fis = new FileInputStream("example.txt");
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
BufferedReader br = new BufferedReader(isr);
// 通过 BufferedReader 读取字符数据
br.close();

OutputStreamWriter: Konvertiert einen Byte-Ausgabestream in einen Zeichen-Ausgabestream.

FileOutputStream fos = new FileOutputStream("output.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
// 通过 BufferedWriter 写入字符数据
bw.close();

4. Objektfluss:

ObjectInputStream: Der Eingabestream, der zum Lesen von Objekten verwendet wird.

FileOutputStream fos = new FileOutputStream("object.dat");
ObjectOutputStream oos = new ObjectOutputStream(fos);

MyClass obj = new MyClass(); // MyClass需要实现Serializable接口
oos.writeObject(obj);

oos.close();

ObjectOutputStream: Der Ausgabestream, der zum Schreiben von Objekten verwendet wird.

FileInputStream fis = new FileInputStream("object.dat");
ObjectInputStream ois = new ObjectInputStream(fis);

MyClass obj = (MyClass) ois.readObject(); // 强制类型转换为实际的对象类型

ois.close();