Dieser Artikel beschreibt die Unterschiede und die Verwendung von Java -Zeichenströmen und Byte -Streams. Teilen Sie es für Ihre Referenz wie folgt weiter:
Der Hauptunterschied zwischen Byte -Streams und Zeichenströmen ist ihre Verarbeitungsmethode
Stream -Klassifizierung:
1. Javas Byte -Stream
InputStream ist der Vorfahr aller Byte -Eingangsströme, während OutputStream der Vorfahr aller Byte -Ausgangsströme ist.
2. Java -Charakterstrom
Der Leser ist der Vorfahr aller Lesestring -Eingabestreams, während der Autor der Vorfahr aller Ausgangszeichenfolgen ist.
InputStream, OutputStream, Leser und Schriftsteller sind alle abstrakten Klassen. Sie können also nicht einfach neu
Byteströme sind die grundlegendsten. Alle Unterklassen von InputStream und OutputStream werden hauptsächlich zur Verarbeitung von Binärdaten verwendet. Sie werden von Bytes verarbeitet, aber in Wirklichkeit sind viele Daten Text. Das Konzept der Zeichenströme wird vorgeschlagen. Sie werden gemäß der Enkodierung der virtuellen Maschine verarbeitet, dh, um die Zeichensätze zu konvertieren. Die beiden werden über InputStreamReader und OutputStreamWriter verwandt und tatsächlich über Byte [] und String verwandt.
Die chinesischen Charakterprobleme, die in der tatsächlichen Entwicklung auftreten, werden tatsächlich durch inkonsistente Umwandlung zwischen Charakterströmen und Byte -Streams verursacht.
Beim Konvertieren von Byte -Stream in Zeichenstrom wird Byte [] in die Zeichenfolge konvertiert.
öffentliche Zeichenfolge (Byte Bytes [], String charSetName)
Es gibt eine Kodierung des Schlüsselparametersatzes, die wir normalerweise weglassen, sodass das System das Betriebssystem Lang verwendet
Wenn ein Zeichenstrom in einen Byte -Stream konvertiert wird, wird tatsächlich, wenn eine Zeichenfolge in Byte [] konvertiert wird, konvertiert.
byte [] string.getBytes (String charSetName)
Gleiches gilt für viele andere Streams in Java.io, hauptsächlich zur Verbesserung der Leistung und zur Verwendung von Komfort.
Wie: BufferedInputStream, PipedInputStream usw.
Spezifische Implementierung
Byte Stream FileInputStream FileOutputStream
Zeichenstreaming -Filereader -Dateiwriter
Die Einheit der Zeichenstromverarbeitung ist 2 Byte -Unicode -Zeichen, die Zeichen, Zeichenarrays oder Zeichenfolgen bedienen, während die Einheit der Byte -Stream -Verarbeitung 1 Byte ist, die Byte- und Byte -Arrays betreibt. Daher besteht der Charakterstrom aus einer java -virtuellen Maschine, die Bytes in 2 Bytes von Unicode -Zeichen umwandelt, sodass er für mehrere Sprachen unterstützender ist! Wenn es sich um eine Audio -Datei, ein Bild oder ein Lied handelt, verwenden Sie Byte -Streaming und wenn sie sich auf Chinesisch (Text) beziehen, verwenden Sie das Streaming von Zeichen.
Alle Dateien werden in Bytes gespeichert. Was auf der Festplatte aufbewahrt wird, sind nicht die Zeichen der Datei, sondern die Zeichen werden zuerst in Bytes codiert, und dann werden die Bytes auf der Festplatte gespeichert. Beim Lesen von Dateien (insbesondere Textdateien) werden sie auch Byte -Byte gelesen, um eine Abfolge von Bytes zu bilden.
Für jede Art von Objekt, einschließlich binärer Objekte, kann ein Byte -Stream verwendet werden, während ein Zeichenstrom nur Zeichen oder Zeichenfolgen verarbeiten kann. 2. Ein Byte -Stream liefert die Funktion, eine Art IO -Operation zu verarbeiten, aber es kann Unicode -Zeichen nicht direkt verarbeiten, während ein Zeichenstrom dies kann.
Byte -Streams können unter Verwendung von InputSteamReader OutputStreamWriter in Zeichenströme konvertiert werden
Konvertieren Sie in BufferDreader BufferedWriter Sie haben Puffer für Beispiel: Lesen Sie Dateien von Byte Stream -Eingabe in die Zeichen des Zeichenstreams ein. Definieren Sie einen Byte -Stream:
FileInputStream FileInputStream = new FileInputStream ("d: /text.txt"); // einen Byte -Stream definieren, der auf d: /text.txt InputStreamReader InputStreamReader zeigt BufferedReader (InputSteamReader); // InputStreamReader konvertiert mit Cache in BufferedReaderSie können den Inhalt der Lesen den Zeichen zuweisen
String ss = new String (); String s; while (s = bufferedReader.readline ())! // einen Byte -Stream definieren, der auf d: /text.txt inputStreamReader inputStreamReader = new InputStreamReader (FileInputStream) zeigt; // Byte -Stream in InputStreamReader BufferedReader BufferedReader = New BufferedReader (InputSteamReader) konvertieren; // InputStreamReader wird mit Cache in einen BufferedReader umgewandelt. Sie können den Inhalt des Lesens dem Zeichen string ss = new String () zuweisen. String S; while ((s = bufferedReader.readline ())! = null) {ss += s; }Zum Beispiel: Schreiben Sie eine Datei aus dem Byte -Stream in die Zeichenstreamausgabe
FileOutputStream FileOutputStream = new FileOutputStream ("d: /text.txt"); // Definieren Sie eine Datei, die auf d: /text.txt outstreamwriter outpreamwriter = new outstreamwriter (FileOutputStream); bufferedWriter bufferWriter = new definieren BufferedWriter (outputStreamWriter); bufferedWriter.Write (s); bufferedWriter.close (); outputStreamwriter.CLOSE (); FileOutputStream FileOutputStream = new FileOutputStream ("d: /text.txt"); // Definieren Sie eine Datei, die auf d: /text.txt -outputStreamwriter outputStreamwriter = neuer OutputStreamWriter (FileOutputStream); BufferedWriter BufferedWriter = neuer BufferedWriter (OuthtStreamWriter); BufferedWriter.Write (s); bufferedWriter.close (); OutputStreamWriter ();Routine:
Konvertieren Strings in Byte -Streams#Region konvertieren Strings in Byte -Streams
/**//// <summary> //// einen String in einen Byte -Stream /// </summary> /// <param name = "_ source"> string </param> // <zurückgegeben> byte stream </return> public static byte [] String2Bytes (String Strsource) {System.io.ioMeMory.MeMory.MeMory.Memory.Memorystream = New System.ioMory.ioMory.Memory (). System.io.BinaryWriter BinaryWriter = New System.io.BinaryWriter (MemoryStream); BinaryWriter.Write (Strsource); byte [] buffer = memoryStream.getBuffer (); Return Puffer;}#EndregionByteströme in Saiten konvertieren #region konvertieren Byteströme in Saiten
/**//// <summary> //// Byte-Streams in Strings /// </summary> /// <param name = "bytdata"> Byte-Streams </param> // <zurückgegeben> String </returns> public static String bytes2string (Byte [] bytdata) {// // //Team2 = System.io.MemoryStream (bytdata); System.io.BinaryReader BinaryReader = New System.io.BinaryReader (MemoryStream2); String S2 = BinaryReader.readstring (); Return S2;}#EndregionIch hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.