Was ist der Unterschied zwischen Java-Zeichenstrom und Bytestrom?

Der Unterschied zwischen Zeichenstrom und Bytestrom in Java: (empfohlen: Java-Video-Tutorial)

1. Die Grundeinheit von Byte-Stream-Operationen ist Byte; die Grundeinheit von Zeichen-Stream-Operationen ist das Unicode-Codeelement.

2. Byte-Stream verwendet standardmäßig keinen Puffer;

3. Byte-Stream wird normalerweise zur Verarbeitung von Binärdaten verwendet, unterstützt jedoch nicht das direkte Schreiben oder Lesen von Unicode-Code-Elementen. das das Schreiben und Lesen von Unicode-Codeeinheiten unterstützt.

Byte-Stream

Die grundlegendste Einheit der Byte-Stream-Verarbeitung in Java ist ein einzelnes Byte, das normalerweise zur Verarbeitung von Binärdaten verwendet wird. Die beiden grundlegendsten Bytestream-Klassen in Java sind InputStream und OutputStream, die den grundlegenden Eingabebytestream bzw. Ausgabebytestream darstellen.

Sowohl die InputStream-Klasse als auch die OutputStream-Klasse sind abstrakte Klassen. Im tatsächlichen Gebrauch verwenden wir normalerweise eine Reihe ihrer Unterklassen, die in der Java-Klassenbibliothek bereitgestellt werden. Nehmen wir die InputStream-Klasse als Beispiel, um den Byte-Stream in Java einzuführen.

Die InputStream-Klasse definiert eine grundlegende Lesemethode zum Lesen von Bytes aus einem Byte-Stream. Die Definition dieser Methode lautet wie folgt:

public abstract int read() throws IOException;

Dies ist eine abstrakte Methode, also ein beliebiger Eingabe-Byte-Stream Die von InputStream abgeleitete Klasse muss ein Byte aus dem Byte-Stream lesen. Wenn sie das Ende erreicht, gibt sie das gelesene Byte zurück.

Was wir bei dieser Methode beachten müssen, ist, dass sie blockiert, bis sie ein gelesenes Byte oder -1 zurückgibt. Darüber hinaus unterstützen Byte-Streams standardmäßig kein Caching, was bedeutet, dass das Betriebssystem bei jedem Aufruf der Lesemethode aufgefordert wird, ein Byte zu lesen, was häufig mit einer Festplatten-E/A einhergeht, sodass die Effizienz relativ gering ist.

Einige Freunde denken vielleicht, dass die überladene Lesemethode in der InputStream-Klasse, die ein Byte-Array als Parameter verwendet, mehrere Bytes gleichzeitig ohne häufige Festplatten-E/A lesen kann. Ist das also wirklich so? Schauen wir uns den Quellcode dieser Methode an:

public int read(byte b[]) throws IOException {
    return read(b, 0, b.length);
}

Sie ruft eine andere Version der Read-Overload-Methode auf, also machen wir weiter:

public int read(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        int c = read();
        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;

        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;
    }

Aus dem obigen Code können wir sehen: Ja, Tatsächlich liest die Methode read(byte[]) auch ein Byte-Array „nacheinander“, indem sie die Methode read() in einer Schleife aufruft, sodass diese Methode im Wesentlichen nicht den Speicherpuffer verwendet. Um einen Speicherpuffer zur Verbesserung der Leseeffizienz zu verwenden, sollten wir BufferedInputStream verwenden.

Zeichenstrom

Die grundlegendste Einheit der Zeichenstromverarbeitung in Java ist die Unicode-Codeeinheit (Größe 2 Byte), die normalerweise zur Verarbeitung von Textdaten verwendet wird. Das sogenannte Unicode-Codeelement ist eine Unicode-Codeeinheit im Bereich von 0x0000 bis 0xFFFF. Jede Zahl im obigen Bereich entspricht einem Zeichen. Der String-Typ in Java codiert Zeichen standardmäßig gemäß den Unicode-Regeln und speichert sie dann im Speicher.

Im Gegensatz zur Speicherung im Speicher verfügen die auf der Festplatte gespeicherten Daten jedoch in der Regel über verschiedene Kodierungsmethoden. Bei Verwendung unterschiedlicher Codierungsmethoden haben dieselben Zeichen unterschiedliche binäre Darstellungen. Tatsächlich funktioniert der Zeichenstrom wie folgt:

Ausgabezeichenstrom: Konvertieren Sie die in die Datei zu schreibende Zeichenfolge (eigentlich eine Unicode-Codeelementsequenz) in eine Bytesequenz in der angegebenen Codierungsmethode und dann In die Datei schreiben;

Eingabezeichenstrom: Dekodieren Sie die zu lesende Bytesequenz in die entsprechende Zeichenfolge (eigentlich eine Unicode-Codeelementsequenz) gemäß der angegebenen Codierungsmethode, damit sie in der Datei gespeichert werden kann Erinnerung.

Wir verwenden eine Demo, um unser Verständnis dieses Prozesses zu vertiefen. Der Beispielcode lautet wie folgt:

import java.io.FileWriter;
import java.io.IOException;


public class FileWriterDemo {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        try {
            try {
                fileWriter = new FileWriter("demo.txt");
                fileWriter.write("demo");
            } finally {
                fileWriter.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Für weitere Java-Kenntnisse beachten Sie bitte das Java Basic Tutorial Spalte.

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen Java-Zeichenstrom und Bytestrom?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!