Einführung und Beispielanalyse der Dateiklasse und des E/A-Streams in Java

IO-Stream:

IO-Stream-Übersicht:

IO: Eingabe/Ausgabe (Eingabe/Ausgabe)

Stream: Es handelt sich um ein abstraktes Konzept und einen allgemeinen Begriff für Datenübertragung . . Das heißt, die Übertragung von Daten zwischen Geräten wird als Stream bezeichnet. E/A-Streams werden verwendet, um Datenübertragungsprobleme zwischen Geräten zu lösen. usw. Kurz gesagt: Bei der Übertragung handelt es sich um Streams.

IO-Flusssystemdiagramm:

Da IO Dateioperationen umfasst, muss es untrennbar mit der Dateioperationstechnologie verbunden sein:

Dateiklasse:

Die Dateiklasse befindet sich im java.io-Paket Objekt, das die Festplattendatei selbst darstellt. Die Dateiklasse definiert einige Methoden zum Betreiben von Dateien, die hauptsächlich zum Abrufen oder Verarbeiten von Informationen zu Festplattendateien verwendet werden, z. B. Dateiname, Dateipfad, Zugriffsberechtigungen, Änderungsdatum usw., und kann auch die Unterverzeichnishierarchie durchsuchen.

Die Dateiklasse stellt Informationen zur Verarbeitung von Dateien und Dateisystemen dar. Die File-Klasse hat nicht die Funktion, Informationen aus Dateien zu lesen und in Dateien zu schreiben. Sie beschreibt nur die Eigenschaften der Datei selbst. Daher ist es für Lese- und Schreibvorgänge mit E/A gekoppelt.

Sehen Sie sich zunächst ein zusammenfassendes Diagramm der häufig verwendeten Methoden der File-Klasse an:

Verwenden Sie createNewFile(), um eine Datei zu erstellen:

public class test01 {
    public static void main(String[] args) throws IOException {
		//先建立一个File对象，并传入路径
        File file1 = new File("G://abc.txt");
        //创建空文件，如果没有存在则新建一个，并且返回True,如果存在了就返回false
        System.out.println(file1.createNewFile());   
}

Wenn das Verzeichnis nach der Ausführung nicht über diese Datei verfügt Datei, dann wird eine erstellt und gibt „true“ zurück. Wenn sie bereits vorhanden ist, wird „false“ zurückgegeben, was darauf hinweist, dass die Erstellung fehlgeschlagen ist.

Verwenden Sie mkdir(), um ein Verzeichnis zu erstellen:

File file2 = new File("G://a");
	System.out.println(file2.mkdir());   
//创建一个目录，如果没有存在则新建一个，并且返回True,如果存在了就返回false

Verwenden Sie mkdirs(), um ein mehrstufiges Verzeichnis zu erstellen:

File file3 = new File("G://a//b//c");
        System.out.println(file3.mkdirs());   
//创建多级目录，如果没有存在则新建一个，并且返回True,如果存在了就返回false

Dann müssen wir die Funktion verwenden im E/A-Stream zur Eingabe der Datei und Ausgabe:

Stellen Sie zunächst vier häufig verwendete Streams vor:

• Byte-Eingabestream: InputStreamInputStream

• 字节输出流：OutputStream

• 字符输入流：Reader

• 字符输出流：Writer

Byte-Ausgabestream: OutputStream< /code> <p><strong></strong></p>Zeicheneingabestream: <code>Reader

Zeichenausgabestream: Writer

Warum gibt es zwei Streams, Byte und Zeichen?

Im ASCII-Code

ist ein englischer Buchstabe (unabhängig von Groß- und Kleinschreibung) ein Byte und ein chinesisches Zeichen zwei Bytes.

Bei der UTF-8-Kodierung besteht ein englisches Wort aus einem Byte und ein chinesisches Wort aus drei Bytes.

Bei der Unicode-Kodierung besteht ein englisches Wort aus einem Byte und ein chinesisches Wort aus zwei Bytes.

Wir wissen also, dass der Computer Daten einzeln liest. Wenn die Datei Zahlen oder Englisch enthält, können sie normal gelesen werden, da sie alle ein Byte belegen.

Und was ist, wenn es chinesische Schriftzeichen sind? Es belegt mindestens zwei Bytes, wenn ein chinesisches Zeichen geteilt und gelesen wird, wird es definitiv ein Problem mit der Anzeige geben.

Zusammenfassung:

Wenn die Daten über die mit Windows gelieferte Notepad-Software geöffnet werden und wir den darin enthaltenen Inhalt trotzdem lesen können, verwenden Sie den Zeichenstrom, andernfalls den Bytestrom. Wenn Sie nicht wissen, welchen Stream-Typ Sie verwenden sollen, verwenden Sie einen Byte-Stream!

Das Folgende ist eine Übersichtstabelle mit Methodennamen für die entsprechenden Funktionen der vier Streams:

Byte-Ausgabestream:

Wir verwenden den Byte-Ausgabestream, um einen Satz in die abc.txt-Datei zu schreiben : ?? Wenn die Datei jetzt die vier Wörter „I love China“ enthält, verwenden Sie den folgenden Code:

public class test01 {
    public static void main(String[] args) {

        try{
              //创建输出流对象：
            OutputStream fos = null;
            fos = new FileOutputStream("G://abc.txt");
            String str = "今天的博客是IO流";
            //先将需要写入的字符打散成数组：
            byte[] words = str.getBytes();
            //使用写入的功能
            fos.write(words);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Das Ausgabeergebnis lautet:

Ändern Sie dann die Informationen in der Datei in Englisch und Zahlen :

Fazit: Dateien mit chinesischen Schriftzeichen können nicht mit Bytestreams gelesen werden

字符输出流：

我们使用字符输出流给abc.txt文件里面写几句话：

public class test03 {
    public static void main(String[] args) {
        try{
            //使用字符输出流的FileWriter写入数据
            Writer fw = new FileWriter("G://abc.txt");
            fw.write("我们在学Java");
            fw.write("一起加油");
            fw.close(); //关闭资源
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

也没用问题，我们发现，使用字符流写中文汉字更方便。

字符输入流：

可以设置缓存流提高获取值的效率：

public class test04 {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象：
        Reader fr = null;
        try{
            fr = new FileReader("G:/abc.txt");
            //借助字符流对象创建了字符缓存区 把字符一个一个的取到后先放到缓存区
            //然后一起再读写到程序内存来，效率更高
            BufferedReader br = new BufferedReader(fr);
            //先去缓存区一行一行的读取
            String line = br.readLine();
            while(line != null){
                System.out.println(line);
                line = br.readLine();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

当文件内的信息为多行的时候：

字节流和字符流总结：

• IO是文件的输入和输出，我们要想去对文件或者写，或者通过程序发送消息给另外的用户都要用到流。

• IO流分 字节流和字符流，字节流是以字节为单位IO，字符流是以字符为单位IO；通常读写图片、视频音频等用字节 流，如果读写文件的内容比如中文建议用字符流。

Das obige ist der detaillierte Inhalt vonEinführung und Beispielanalyse der Dateiklasse und des E/A-Streams in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!