1. Was ist Fluss?
2. Was ist ein Eingabestream?
Es gibt zwei abstrakte Klassen für Eingabestreams, den InputStream-Byte-Eingabestream und den Reader-Zeichen-Eingabestream
(1) InputStream-Klasse
Die InputStream-Klasse ist eine abstrakte Klasse von Byte-Eingabestreams und die übergeordnete Klasse aller Byte-Eingabestreams.
Die spezifische Strukturebene der
Klasse lautet wie folgt: Alle Methoden in der InputStream-Klasse lösen bei Auftreten eines Fehlers eine IOException aus. Allgemeine Methoden und Beschreibungen dieser Klasse Wie in der Tabelle gezeigt:
Hinweis: Nicht alle Unterklassen der inputStream-Klasse unterstützen die in inputStream definierten Methoden. Die Methoden skip (), mark (), reset () und andere sind nur für einige Unterklassen nützlich.
(Zwei) Leserklasse
Die Zeichen in Java sind Unicode-Codierung, Doppelbytes, und die InputStream-Klasse wird zur Ausgabe von Einzelbytes verwendet, was nicht für die Verarbeitung von Zeichen geeignet ist. Aus diesem Grund bietet Java eine Reader-Klasse, die speziell zur Verarbeitung von Zeichen verwendet wird. Die Reader-Klasse ist ein Zeichen Die abstrakte Klasse des Eingabestreams ist auch die übergeordnete Klasse aller Zeicheneingabestreams. Die spezifische hierarchische Struktur der Reader-Klasse lautet wie folgt:
Hinweis:
Der Parameter der read () -Methode der Reader-Klasse ist ein Array vom Typ char. Darüber hinaus bietet die Reader-Klasse eine ready () -Methode, mit der bestimmt wird, ob der Stream gelesen werden soll, und deren Rückgabewert vom Typ boolean ist.
3. Was ist ein Ausgabestream?
Es gibt auch zwei Arten von abstrakten Klassen für Ausgabestreams, nämlich den OutputStream-Byte-Ausgabestream und den Writer-Zeichenausgabestream
(1) OutputStream-Klasse
Die OutputStream-Klasse ist eine abstrakte Klasse von Byte-Ausgabestreams und die übergeordnete Klasse aller Byte-Ausgabestreams. Die spezifischen Ebenen der
OutputStream-Klasse lauten wie folgt: Alle Methoden in der OutputStream-Klasse haben keinen Rückgabewert, und eine IOException wird ausgelöst, wenn ein Fehler auftritt. Allgemeine Methoden und Beschreibungen der Klasse:
(Zwei) Schriftstellerklasse
Die Writer-Klasse ist eine abstrakte Klasse von Zeichenausgabestreams und die übergeordnete Klasse aller Zeichenausgabestreams. Die Hierarchie der Writer-Klasse lautet wie folgt:
Die allgemeinen Methoden und Beschreibungen der Writer-Klasse lauten wie folgt:
Viertens die File-Klasse
(1) Erstellen Sie ein Dateiobjekt
(Zwei) die Verwendung der Dateiklasse
(3) Dateivorgang
(3) Ordneroperation
Fünftens Dateieingabe- / Ausgabestream
Während der Ausführung des Programms werden die meisten Daten im Speicher gespeichert. Wenn das Programm beendet oder geschlossen wird, verschwinden die im Speicher gespeicherten Daten. Wenn Sie die Daten dauerhaft speichern müssen, können Sie sie am besten in einer Datenträgerdatei speichern Stellen Sie hierfür die folgenden Klassen bereit
(1) FileInputStream-Klasse und FileOutputStream-Klasse
FileInputStream-Klasse: Wird zum Lesen des Inhalts der Datei verwendet.
FileOutputStream-Klasse: Wird zum Schreiben des Inhalts in die Datei verwendet
Fall Analyse:
public class FileStreamTest {
public static void main(String[] args) {
File file = new File("word.txt"); // 创建文件对象
try {
// 捕捉异常
// 创建FileOutputStream对象，用来向文件中写入数据
FileOutputStream out = new FileOutputStream(file);
// 定义字符串，用来存储要写入文件的内容
String content = "你见过洛杉矶凌晨4点的样子吗？";
// 创建byte型数组，将要写入文件的内容转换为字节数组
byte buy[] = content.getBytes();
out.write(buy); // 将数组中的信息写入到文件中
out.close(); // 将流关闭
} catch (IOException e) {
// catch语句处理异常信息
e.printStackTrace(); // 输出异常信息
}
try {
// 创建FileInputStream对象，用来读取文件内容
FileInputStream in = new FileInputStream(file);
byte byt[] = new byte[1024]; // 创建byte数组，用来存储读取到的内容
int len = in.read(byt); // 从文件中读取信息，并存入字节数组中
// 将文件中的信息输出
System.out.println("文件中的信息是：" + new String(byt, 0, len));
in.close(); // 关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
}
(2) Dateizeichenstrom: FileReader-Klasse und FileWriter-Klasse
Verwenden Sie den Zeichenstrom, um verstümmelte Zeichen beim Schreiben von Dateien zu vermeiden.
Fall Analyse:
public class Demo1 {
public static void main(String[] args) {
File f = new File("E:\\untitled\\src\\cn\\tx\\Exceriser200\\text005\\word.txt");
/*
FileWriter fw = null;
String st = "天行健，自强不息；地势坤，厚德载物";
try {
//加true 表示在源文件后追加新内容
fw = new FileWriter(f,true);
fw.write(st);
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fw != null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}*/
FileReader fr = null;
try {
fr = new FileReader(f);
//创建缓冲区 读取数据
char ch[] = new char[1024];
//已经读出的字符数
int count;
//循环读取文件中的数据 直到所有字符都读完
while((count = fr.read(ch))!=-1){
System.out.println("文件中的内容为："+new String(ch,0,count));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fr != null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Fünf gepufferte Eingabe- / Ausgabestreams
（（） BufferedInputStream 与 BufferedOutputStream
Fall Analyse:
public class BufferedStreamTest {
public static void main(String args[]) {
// 定义字符串数组
String content[] = {
"你不喜欢我，", "我一点都不介意。", "因为我活下来，", "不是为了取悦你！" };
File file = new File("word.txt"); // 创建文件对象
FileOutputStream fos = null; // 创建FileOutputStream对象
BufferedOutputStream bos = null; // 创建BufferedOutputStream对象
FileInputStream fis = null; // 创建FileInputStream对象
BufferedInputStream bis = null; // 创建BufferedInputStream对象
try {
fos = new FileOutputStream(file); // 实例化FileOutputStream对象
bos = new BufferedOutputStream(fos); // 实例化BufferedOutputStream对象
byte[] bContent = new byte[1024]; // 创建可以容纳1024个字节数的缓冲区
for (int k = 0; k < content.length; k++) {
// 循环遍历数组
bContent = content[k].getBytes(); // 将遍历到的数组内容转换为字节数组
bos.write(bContent); // 将字节数组内容写入文件
}
System.out.println("写入成功！\n");
} catch (IOException e) {
// 处理异常
e.printStackTrace();
} finally {
try {
bos.close(); // 将BufferedOutputStream流关闭
fos.close(); // 将FileOutputStream流关闭
} catch (IOException e) {
e.printStackTrace();
}
}
try {
fis = new FileInputStream(file); // 实例化FileInputStream对象
bis = new BufferedInputStream(fis); // 实例化BufferedInputStream对象
byte[] bContent = new byte[1024]; // 创建byte数组，用来存储读取到的内容
int len = bis.read(bContent); // 从文件中读取信息，并存入字节数组中
// 输出文件数据
System.out.println("文件中的信息是：" + new String(bContent, 0, len));
} catch (IOException e) {
// 处理异常
e.printStackTrace();
} finally {
try {
bis.close(); // 将BufferedInputStream流关闭
fis.close(); // 将FileInputStream流关闭
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
（（） BufferedReader 与 BufferedWriter
1. Allgemeine Methoden
der BufferedReader-Klasse 2. Allgemeine Methoden der BufferedWriter-Klasse
3. Fallanalyse
public class Demo4 {
public static void main(String[] args) {
File file = new File("word.txt");
/* 写入内容到文件里 */
FileWriter fw = null;
BufferedWriter bw = null;
try {
fw = new FileWriter(file);
//将文本字符输出流包装成缓冲字符流
bw = new BufferedWriter(fw);
String str1 = "世界这么大";
String str2 = "我想去看看";
//第一行的数据
bw.write(str1);
//创建新行
bw.newLine();
//第二行的数据
bw.write(str2);
} catch (IOException e) {
e.printStackTrace();
}finally {
//要注意流的关闭顺序，先创建后关闭
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fw != null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/* 读取文件里内容 */
FileReader fr = null;
BufferedReader br = null;
try {
fr = new FileReader(file);
//将文本字符输入流包装成缓冲字符输入流
br = new BufferedReader(fr);
String tem = null;
int i = 1;
while ((tem = br.readLine()) != null){
System.out.println("第"+i+"行:"+tem);
i++;
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(br !=null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fr != null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6. Schwierigkeiten
(1) Der Unterschied zwischen Bytestrom und Zeichenstrom
Der Byte-Stream endet mit Stream und der Zeichen-Stream endet mit Reader oder Writer. Der Zeichenstrom wird nach Zeichen gelesen und geschrieben, und alle können Textinformationen gut verarbeiten. Der Bytestream wird gemäß dem kleinsten Byte gelesen und geschrieben, sodass der Bytestream alle Datenströme verarbeiten kann, die Funktion jedoch nicht so groß ist wie der Zeichenstrom.
(2) Verwendung von Eingabe- / Ausgabestreams
Wenn Daten als Referenzobjekt verwendet werden und Daten von der Datei in den Speicher fließen, ist der Eingabestream erforderlich. Wenn die Daten vom Speicher in die Datei fließen, ist der Ausgabestream erforderlich (Drucken der Daten auf dem Monitor ist eine Art).