Ausführliche Erläuterung der allgemeinen Operationen von Java IO (Codebeispiel)

Überblick

Java-E/A-Operationen beziehen sich auf Dateneingabe-/ausgabeoperationen.

Die E/A-Operationsklassen von Java befinden sich im Paket java.io und sind hauptsächlich in die folgenden Kategorien unterteilt:

• E/A-Schnittstelle basierend auf Byte-Operation: InputStream und OutputStream
• E/A-Schnittstelle basierend auf Zeichenoperation: Writer und Reader
• E/A-Schnittstelle basierend auf Festplattenbetrieb: Datei

1. Einführung in die Kernklassen

• Bytebasierte E/A-Operationen, der Kern besteht darin, das Byte-Array byte[] zu betreiben, das jede Art von Stream-Daten verarbeiten kann
• Zeichenbasierte I/O-Operationen, der Kern soll das Zeichen-Array char[] bedienen und kann nur zeichenartige Stream-Daten verarbeiten.Wenn es sich um Nicht-Zeichen-Stream-Daten (wie Bilder, Videos usw.) wird verstümmelt

1. Byte-Eingangsstrom

Art	Funktion	veranschaulichen
ByteArrayInputStream	Verwenden Sie den Speicherpuffer als InputStream	Verbinden Sie es mit dem FilterInputStream-Objekt, um den Bytestream in der Datei zu speichern
FileInputStream	Informationen aus einer Datei lesen	Konvertieren Sie das Dateiobjekt File in einen Eingabestream, um die Daten in der Datei zu lesen
FilterInputStream	Eine abstrakte Klasse, die als Decorator-Schnittstelle fungiert und nützliche Funktionen für andere InputStream-Klassen bereitstellt
BufferedInputStream	Bietet Pufferoperationen zur Verbesserung der E/A-Leistung; Pufferfunktion für eingehende Eingabeströme hinzufügen	FilterInputStream-Unterklasse
DataInputStream	Wird in Verbindung mit DataOutputStream verwendet, um grundlegende Datentypen portiert aus Streams zu lesen; enthält alle Schnittstellen zum Lesen grundlegender Datentypen	FilterInputStream-Unterklasse

2. Byte-Ausgangsstrom

Art	Funktion	veranschaulichen
ByteArrayOutputStream	Erstellen Sie einen Puffer im Speicher. Alle an den Stream gesendeten Daten werden in diesen Puffer gestellt	Es ist praktisch, den Eingabestrom in ein Byte-Array umzuwandeln
FileOutputStream	zum Schreiben von Informationen in eine Datei
FilterOutputStream	Abstrakte Klasse, Schnittstelle, die als Decorator fungiert und nützliche Funktionen für andere OutputStreams bereitstellt
BufferedOutputStream	Bietet Pufferoperationen zur Verbesserung der E/A-Leistung; fügen Sie dem eingehenden Ausgabestrom eine Pufferfunktion hinzu, Sie können flush() aufrufen, um den Puffer zu löschen	FilterOutputStream-Unterklasse
DataOutputStream	In Verbindung mit DataInputStream können Basisdatentypen transplantiert in den Stream geschrieben werden, der alle Schnittstellen zum Schreiben von Basisdatentypen enthält	FilterOutputStream-Unterklasse

3. Zeicheneingabestrom

Art	Funktion	veranschaulichen
InputStreamReader	Konvertieren Sie den Byte-Eingabestrom InputStream in den Zeicheneingabestrom
FileReader	Konvertiert das Dateiobjekt File in einen Zeicheneingabestream	Unterklasse von InputStreamReader
BufferedReader	Bereitstellung einer Pufferfunktion zur Verbesserung der Betriebsleistung des Zeicheneingabestrom-Lesegeräts
StringReader	Konvertieren Sie eine Zeichenfolge in eine Zeichenstromoperation

4. Zeichenausgabestrom

Art	Funktion	veranschaulichen
OutputStreamWriter	Wandeln Sie den Byte-Ausgabestrom OutputStream in den Zeichenausgabestrom um
FileWriter	Konvertiert das Dateiobjekt File in einen Zeichenausgabestream	Unterklasse von OutputStreamWriter
BufferedWriter	Stellen Sie eine Pufferfunktion bereit, um die Betriebsleistung des Writer für den Zeichenausgabestrom zu verbessern
StringWriter	Konvertieren Sie eine Zeichenfolge in eine Zeichenstromoperation

2. Einführung in die Tastenbedienung

1. Schließen Sie den Stream

Alle Datenströme müssen die close-Methode aufrufen, um sie zu schließen, nachdem die Operation abgeschlossen ist. In 1.7 und höher wird empfohlen, die try-with-resourcesAnweisung zu verwenden, um den Stream zu verwenden, wodurch das explizite Aufrufen der close()-Methode vermieden und wiederholter Code reduziert werden kann. und automatisch close aufrufen, nachdem die Operation abgeschlossen ist.

try-with-resourcesDie Anweisung kann automatisch alle java.io.CloseableUnterklassenobjekte schließen, die die Schnittstelle implementieren.

 try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file))) {
    
    
     bos.write(content.getBytes());
     bos.flush();
 }

2. Aktualisieren Sie den Cache

Die Methode flush() wird verwendet, um das OutputStream-Objekt zu zwingen, die temporär im internen Puffer gespeicherten Daten sofort zu schreiben (im Allgemeinen ist es nicht notwendig, diese Methode manuell aufzurufen, und die eigentlichen Daten werden automatisch ausgeführt, nachdem der interne Puffer geladen wurde Die Schreiboperation ruft auch automatisch die Methode flush() auf, wenn die Methode close() aufgerufen wird)

3. Serialisierungsstream und Deserialisierungsstream

Die Serialisierung eines Objekts besteht darin, das Objekt in eine Bytesequenz umzuwandeln, und umgekehrt wird als Deserialisierung bezeichnet, ObjectOutputStream ist ein Serialisierungsstream und ObjectInputStream ist ein Deserialisierungsstream.

Das zu bedienende Objekt muss die Serialisierungsschnittstelle Serializable implementieren.Wenn Sie möchten, dass ein bestimmtes Feld nicht serialisiert wird, können Sie das Feld mit transient so modifizieren, dass das Feld nicht serialisiert wird, oder Sie können es manuell durch Umschreiben von und serialisieren Methoden writeObjectOverride().readObjectOverride()

Statische Variablen können auch nicht serialisiert werden, da alle Objekte den gleichen statischen Variablenwert teilen

1) ObjectOutputStream-Serialisierungsstream

Die Hauptmethode ist writeObject, die die Klasse des Objekts, die Signatur der Klasse und die Werte aller nicht statischen und nicht transienten Felder in dieser Klasse und ihren übergeordneten Klassen speichert

public final void writeObject(Object obj) throws IOException {
    
    
    if (enableOverride) {
    
    
        writeObjectOverride(obj);
        return;
    }
    try {
    
    
        writeObject0(obj, false);
    } catch (IOException ex) {
    
    
        if (depth == 0) {
    
    
            writeFatalException(ex);
        }
        throw ex;
    }
}

2) ObjectInputStream-Deserialisierungsstrom

Die Hauptmethode ist readObject, die die Klasse des Objekts, die Signatur der Klasse und die Werte aller nicht statischen und nicht transienten Felder in dieser Klasse und ihren Oberklassen zurückliest

    public final Object readObject()
        throws IOException, ClassNotFoundException
    {
    
    
        if (enableOverride) {
    
    
            return readObjectOverride();
        }

        // if nested read, passHandle contains handle of enclosing object
        int outerHandle = passHandle;
        try {
    
    
            Object obj = readObject0(false);
            handles.markDependency(outerHandle, passHandle);
            ClassNotFoundException ex = handles.lookupException(passHandle);
            if (ex != null) {
    
    
                throw ex;
            }
            if (depth == 0) {
    
    
                vlist.doCallbacks();
            }
            return obj;
        } finally {
    
    
            passHandle = outerHandle;
            if (closed && depth == 0) {
    
    
                clear();
            }
        }
    }

3. Codebeispiel

import org.springframework.util.StopWatch;
import java.io.*;
public class FileUtilTest {
    
    
    /**
     * 复制文件
     */
    public static void copyFile(String fromFileName, String toFileName) throws Exception {
    
    
        File fromFile = new File(fromFileName);
        File toFile = new File(toFileName);
        StopWatch watch = new StopWatch("fileTest");
        watch.start("copy");

        if (!fromFile.exists()) {
    
    
            System.out.println("源文件不存在");
            System.exit(1);
        }
        if (!toFile.getParentFile().exists()) {
    
    
            toFile.getParentFile().mkdirs();
        }

        try (InputStream is = new FileInputStream(fromFile);
             OutputStream os = new FileOutputStream(toFile)) {
    
    
            int temp = 0;
            byte[] data = new byte[4096];

            while ((temp = is.read(data)) != -1) {
    
    
                os.write(data, 0, temp);
            }
            watch.stop();
            System.out.println(watch.prettyPrint());
        }
    }

    /**
     * 通过字符流将字符串写入到文件中
     */
    public static void write(String fileName, String content) throws IOException {
    
    

        File file = new File(fileName);
        if (!file.getParentFile().exists()) {
    
    
            file.getParentFile().mkdirs();
        }
        try (Writer out = new FileWriter(file)) {
    
    
            out.write(content);
            out.flush();
        }
    }

    /**
     * 通过字节流将字符串写入到文件中，增加缓冲区功能
     */
    public static void writeBuffer(String fileName, String content) throws IOException {
    
    
        File file = new File(fileName);
        if (!file.getParentFile().exists()) {
    
    
            file.getParentFile().mkdirs();
        }
        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file))) {
    
    
            bos.write(content.getBytes());
            bos.flush();
        }
    }

    /**
     * 通过字符流将字符串写入到文件中，增加缓冲区功能
     */
    public static void writeBufferedWriter(String fileName, String content) {
    
    
        File file = new File(fileName);
        if (!file.getParentFile().exists()) {
    
    
            file.getParentFile().mkdirs();
        }
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))) {
    
    
            bw.write(content);
            bw.flush();
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

    /**
     * 通过字符流，从文件中读取字符串内容
     */
    public static void readChar(String fileName) {
    
    
        File file = new File(fileName);
        if (!file.exists()) {
    
    
            return;
        }
        try (Reader in = new FileReader(file)) {
    
    
            char[] data = new char[4096];
            int len;
            StringBuilder sb = new StringBuilder();
            while ((len = in.read(data)) != -1) {
    
    
                sb.append(new String(data, 0, len));
            }
            in.close();
            System.out.println(sb);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }

    }

    /**
     * 通过字节流，从文件中读取字符串内容
     */
    public static void readByte(String fileName) throws IOException {
    
    
        File file = new File(fileName);
        if (!file.exists()) {
    
    
            return;
        }
        try (InputStream in = new FileInputStream(file)) {
    
    
            byte[] data = new byte[4096];
            int len;
            StringBuilder sb = new StringBuilder();
            while ((len = in.read(data)) != -1) {
    
    
                sb.append(new String(data, 0, len));
            }
            System.out.println(sb);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

    /**
     * 通过字符流，从文件中读取字符串内容，增加缓冲区功能
     */
    public static void readBufferReader(String fileName) throws Exception {
    
    
        File file = new File(fileName);
        if (!file.exists()) {
    
    
            return;
        }
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) {
    
    
            String line;
            while ((line = bufferedReader.readLine()) != null) {
    
    
                System.out.println(line);
            }
        }

    }

    /**
     * 通过字节流，从文件中读取字符串内容，增加缓冲区功能
     */
    public static void readBuffer(String fileName) throws Exception {
    
    
        File file = new File(fileName);
        if (!file.exists()) {
    
    
            return;
        }
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file))) {
    
    
            int len;
            byte[] data = new byte[4096];
            while ((len = bis.read(data)) != -1) {
    
    
                System.out.println(new String(data, 0, len));
            }
        }
    }

    /**
     * 将文件内容转换成字节数组
     */
    public static byte[] file2OutStream(String fileName) throws Exception {
    
    
        File file = new File(fileName);
        if (!file.exists()) {
    
    
            return null;
        }
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
             ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
    
    
            int len;
            byte[] data = new byte[4096];
            while ((len = bis.read(data)) != -1) {
    
    
                bos.write(data, 0, len);
            }
            return bos.toByteArray();
        }
    }

    /**
     * 将Java对象序列化存储在到文件中
     */
    public static void objWrite(String fileName) {
    
    
        File file = new File(fileName);
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file))) {
    
    
            oos.writeObject("Hello ,World");
            oos.writeBoolean(false);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

    /**
     * 从序列化文件中反序列化出Java对象
     */
    public static void objRead(String fileName) {
    
    
        File file = new File(fileName);
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
    
    
            Object o = ois.readObject();
            System.out.println(o.getClass());
            System.out.println("o = " + o);
            System.out.println("ois.readBoolean() = " + ois.readBoolean());
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

}