Analyse de la différence et de l'utilisation du flux de caractère Java et du flux d'octets

Cet article décrit les différences et l'utilisation des flux de personnages Java et des flux d'octets. Partagez-le pour votre référence, comme suit:

La principale différence entre les flux d'octets et les flux de caractères est leur méthode de traitement

Classification des flux:

1. Stream d'octets de Java

InputStream est l'ancêtre de tous les flux d'entrée d'octets, tandis que OutputStream est l'ancêtre de tous les flux de sortie d'octets.

2. Stream de personnage Java

Lecteur est l'ancêtre de tous les flux d'entrée de chaîne de lecture, tandis que l'écrivain est l'ancêtre de toutes les chaînes de sortie.

InputStream, OutputStream, Reader et Writer sont toutes des classes abstraites. Vous ne pouvez donc pas simplement nouveau
Les flux d'octets sont les plus élémentaires. Toutes les sous-classes de InputStream et OutputStream sont principalement utilisées pour traiter les données binaires. Ils sont traités par des octets, mais en réalité, beaucoup de données sont du texte. Le concept de flux de caractères est proposé. Ils sont traités en fonction de l'encodage de la machine virtuelle, c'est-à-dire pour convertir les jeux de caractères. Les deux sont liés via InputStreamReader et OutputStreamWriter, et sont en fait liés via Byte [] et String.

Les problèmes de caractère chinois qui surviennent dans le développement réel sont en fait causés par une conversion incohérente entre les flux de caractère et les flux d'octets.

Lors de la conversion du flux d'octets en flux de caractères, c'est en fait lorsque l'octet [] est converti en chaîne.

 String public (byte octets [], chaîne charsetName)

Il y a un codage de caractéristiques de paramètres clés, que nous omettons habituellement, donc le système utilise le système d'exploitation Lang
Lorsqu'un flux de caractères est converti en flux d'octets, c'est en fait lorsqu'une chaîne est convertie en octet [],
Byte [] string.getBytes (String charSetName)
Il en va de même que pour de nombreux autres flux de Java.io, principalement pour améliorer les performances et utiliser la commodité.

Comme: BufferedInputStream, PipedInputStream, etc.

Implémentation spécifique

Byte Stream FileInputStream FileOutputStream
Caractère Streaming FileReader Filewriter

L'unité de traitement du flux de caractères est de 2 octets Unicode caractères, qui exploite respectivement des caractères, des réseaux de caractères ou des chaînes, tandis que l'unité de traitement de flux d'octet est de 1 octet, qui fonctionne des byste d'octets et d'octets. Par conséquent, le flux de caractères est composé d'une machine virtuelle Java convertissant des octets en 2 octets de caractères Unicode, il est donc plus favorable à plusieurs langues! S'il s'agit d'un fichier audio, d'une image ou d'une chanson, utilisez le streaming d'octets, et s'il est lié au chinois (texte), utilisez le streaming de caractères.

Tous les fichiers sont stockés en octets. Ce qui est conservé sur le disque n'est pas les caractères du fichier, mais les caractères sont d'abord codés en octets, puis les octets sont stockés sur le disque. Lors de la lecture de fichiers (en particulier des fichiers texte), ils sont également lus octets pour former une séquence d'octets.

Un flux d'octet peut être utilisé pour tout type d'objet, y compris les objets binaires, tandis qu'un flux de caractères ne peut traiter que des caractères ou des chaînes; 2. Un flux d'octet offre la fonction de gestion de tout type d'opération IO, mais il ne peut pas traiter directement les caractères Unicode, tandis qu'un flux de caractères peut le faire.

Les flux d'octets peuvent être convertis en flux de caractères à l'aide de l'entrée de sortie
Convertir en bufferDreader BufferedWriter Ils ont des tampons par exemple: lire les fichiers à partir de l'entrée de flux d'octets vers l'entrée de flux de caractères Définissez un flux d'octet:

 FileInputStream FileInputStream = new FileInputStream ("d: /xt.txt"); // définissez un flux d'octet pointant vers d: /xt.txt inputStreamReader inputStreamReader = new InputStreamReader (FileInputStream); // convertit stream byte en entrée de base BufferedReader (InputSteamReader); // InputStreamReader se convertit en tampon avec cache

Vous pouvez attribuer le contenu de lecture à des caractères

 String ss = new String (); String S; while ((s = buffereDReader.readline ())! = Null) {ss + = s;} fileInputStream fileInputStream = new FileInputStream ("d: /text.txt"); // définir un flux d'octet pointant vers d: /text.txt inputStreamReader inputStreamReader = new inputStreamReader (fileInputStream); // Convertir le flux de byte en InputStreamReader BufferedReader BuffereDReader = new BufferedReader (InputSteamReader); // InputStreamReader est converti en un bilan de tampon avec cache. Vous pouvez attribuer le contenu de lecture aux caractères String ss = new String (); String S; while ((s = bufferedReader.readline ())! = null) {ss + = s; }

Par exemple: écrivez un fichier à partir du flux d'octet vers la sortie du flux de caractères

 FileOutputStream fileoutputStream = new FileOutputStream ("d: /text.txt"); // définir un fichier pointant vers d: /text.txt outputStreamWriter outSutStreamWriter = new OutputStreamWriter (fileoutPutStream); BufferedWriter BufferedWriter = new BufferedWriter (outputStreamWriter); bufferedwriter.write (s); bufferedwriter.close (); outputStreamWriter.close (); fileOutputStream fileoutStream = new fileoutputStream ("d: /xt.txt"); // Définir un fichier pointant vers d: /text.txt outputStreamWriter outSutStreamWriter = new OutputStreamWriter (fileoutputStream); bufferedwriter bufferedwriter = new bufferedWriter (outputStreamWriter); bufferedwriter.write (s); BufferedWriter.Close (); outputStreamwriter.close (); fileoutputStream.close ();

Routine:

Convertir les chaînes en flux d'octets # région Convertir les chaînes en ruisseaux d'octets

 / ** / /// <summary> //// Convertir une chaîne en un flux d'octet /// </ résumé> /// <param name = "_ Source"> String </amar> /// <retourne> BYTE Stream </ Returns> public static byte [] String2Bytes (String StrSource) {System.MemeMorystreamstreamStream = new System.Em.EMMoryStream (); System.io.BinaryWriter BinaryWriter = new System.io.BinaryWriter (MemoryStream); binarywriter.write (strSource); byte [] buffer = mémoire de mémoire.getBuffer (); Retour tampon;} # Endregion

Convertir les ruisseaux d'octets en chaînes #Region Convertir les flux d'octets en chaînes

 / ** / /// <summary> //// convertit les flux d'octets en chaînes /// </summary> /// <param name = "bytdata"> Streams byte </amar> /// <peewards> string </ returns> public stating bytes2String (byte [] bytdata) {// byte stream-> string system.io.MemoryMory System.io.MemoryStream (ByTDATA); System.io.BinaryReader BinaryReader = new System.io.BinaryReader (MemoryStream2); String s2 = binaryReader.readString (); retour s2;} # endregion

J'espère que cet article sera utile à la programmation Java de tous.