TampondInputstream
BufferedInputStream est un flux d'entrée tamponné. Il hérite de FilterInputStream.
Le but de BufferedInputStream est d'ajouter certaines fonctionnalités à un autre flux d'entrée, comme la fourniture de "fonctionnalités tampon" et les méthodes de réinitialisation "Mark () de support" et "réinitialiser ().
BufferedInputStream est essentiellement implémenté via un tableau de tampon interne. Par exemple, après avoir créé un tampondInputStream correspondant à un certain flux d'entrée, lorsque nous lisons les données du flux d'entrée via read (), le tamponInputStream remplira les données du flux d'entrée dans le tampon en lots. Chaque fois que les données du tampon sont lues, le flux d'entrée remplira à nouveau le tampon de données; Cela sera répété jusqu'à ce que nous ayons fini de lire l'emplacement des données du flux d'entrée.
Liste des fonctions de tamponInputStream:
BufferedInputStream (InputStream IN) BufferedInputStream (InputStream in, int size) synchronisé int disponible () void close () synchronisé vide mark (int litlimit) booléen marksupported () synchronisé int linde () synchronisé int (byte [] buffer, bypip (bytecourt) sychronisé VOID RÉSIDE (bytecyte) sychronisé sychronisé rétinu ByteCount)
Exemple de code:
Pour une utilisation détaillée de l'API dans BufferedInputStream, reportez-vous à l'exemple de code (BufferedInputStreamTest.Java):
Importer java.io.BufferedInputStream; import java.io.bytearrayinputStream; import java.io.file; importer java.io.inputstream; importer java.io.fileinpstream; import java.io.ioexception; BufferedInputStream Test Program * * @author Skywang * / classe publique BufferedInputStreamTest {private static final int len = 5; public static void main (String [] args) {testBufferedInputStream (); } / ** * Fonction de test API de BufferedInputStream * / private static void testBufferedInputStream () {// Créer un flux de byte BufferedInputStream, le contenu est un Arraytters Array try {file file = new File ("BufferedInputStream.txt"); InputStream dans = new BufferedInputStream (new FileInputStream (fichier), 512); // Lire 5 octets du flux d'octets. "ABCDE", A correspond à 0x61, b correspond à 0x62, et ainsi de suite ... pour (int i = 0; i <len; i ++) {// si vous pouvez continuer à lire l'octet suivant, lisez le prochain octet if (in.available ()> = 0) {// read " System.out.printf ("% d: 0x% s / n", i, Integer.tohexString (TMP)); }} // Si "ce flux d'octet" ne prend pas en charge la fonction de marquage, quittez directement si (! In.markSupported ()) {System.out.println ("Make Not SupportEd!"); retour ; } // Mark "Position d'index actuelle", c'est-à-dire marquer l'élément de la 6e position - "F" // 1024 correspond à Marklimit dans.mark (1024); // sauter 22 octets. in.skip (22); // Lire 5 octets octets [] buf = nouveau octet [len]; in.read (buf, 0, len); // Convertir BUF en une chaîne de chaîne. String str1 = new String (buf); System.out.printf ("str1 =% s / n", str1); // Réinitialise «l'indice du flux d'entrée» à la position marquée par Mark (), c'est-à-dire réinitialiser avec «F». in.reset (); // Lire 5 octets dans BUF à partir de "réinitialiser le flux d'octets". C'est-à-dire lire "fghij" in.read (buf, 0, len); // Convertir BUF en une chaîne de chaîne. String str2 = new String (buf); System.out.printf ("str2 =% s / n", str2); joindre(); } catch (filenotFoundException e) {e.printStackTrace (); } catch (SecurityException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); }}} Le contenu de BufferedInputStream.txt La lecture dans le programme est la suivante:
abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz
Résultats en cours:
0: 0x611: 0x622: 0x633: 0x644: 0x65str1 = 01234str2 = fghij
Tampon
BufferedOutputStream est un flux de sortie tamponné. Il hérite de FilterOutputStream.
La fonction de BufferedOutputStream est de fournir "tampon" à un autre flux de sortie.
Liste des fonctions tamponnées à OffutStream:
BufferedOutputStream (OutputStream out) tampondoutPutStream (OutputStream out, int size) synchronisé void close () synchronisé void flush () synchronisé void write (byte [] tampon, int compset, intyl) synchronisé vide écrit (int bytete)
Exemple de code:
Pour une utilisation détaillée de l'API dans BufferedOutputStream, reportez-vous à l'exemple de code (tampondoutputStreamTest.java):
Importer java.io.BufferedOutputStream; import java.io.file; import java.io.outputStream; import java.io.fileoutputStream; import java.io.ioexception; import java.io.filenotfoundException; import java.lang.securityException; @author skywang * / classe publique BufferedOutputStreamTest {private static final int len = 5; // correspondant aux lettres anglaises "abcddefghijklmnopqrssttuvwxyz" octet final statique privé [] arrayletters = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a}; public static void main (String [] args) {testBufferedOutputStream (); } / ** * Fonction de test de l'API de BufferedOutputStream * / private static void testBufferedOutputStream () {// Créer le tampon de tampon correspondant à "Stream de sortie de fichier" // Sa taille de tampon correspondante est automatiquement écrite au flux de sortie. try {file file = new File ("out.txt"); OutputStream out = new BufferedOutputStream (new FileOutputStream (fichier), 16); // Écrivez les 10 premiers octets du tableau Arrayletters sur le flux de sortie Out.Write (Arraytters, 0, 10); // Écrivez le "newline / n" sur le flux de sortie out.write ('/ n'); // FAIRE! // out.flush (); readUserInput (); out.close (); } catch (filenotFoundException e) {e.printStackTrace (); } catch (SecurityException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); }} / ** * Lire l'entrée utilisateur * / private static void readUserInput () {System.out.println ("Veuillez saisir un texte:"); Lecteur de scanner = nouveau scanner (System.in); // attendez une chaîne d'entrée str = reader.next (); System.out.printf ("l'entrée est:% s / n", str); }} Résultats en cours:
Générez le fichier "out.txt", et le contenu du fichier est "ABCDEFGHIJ".
Test étape par étape: suivez les trois étapes suivantes pour tester le programme pour afficher la taille du tampon et le rôle de Flush ().
Type 1: programme original
(1) Exécutez le programme. Lorsque le programme attend la saisie de l'utilisateur, vérifiez le contenu texte de "out.txt"; Trouver: le contenu est vide.
(2) Exécutez le programme. Après l'entrée de l'utilisateur, vérifiez le contenu texte de "out.txt"; Find: Le contenu est "ABCDEFGHIJ".
À partir de cela, nous constatons que les résultats de (01) et (02) sont différents; La raison pour laquelle le contenu out.txt dans (01) est vide est que la taille du tampon correspondant à Out.txt est de 16 octets, et nous écrivons uniquement 11 octets, de sorte qu'il n'effectue pas le fonctionnement du tampon clair (c'est-à-dire, écrivez des données de tampon au flux de sortie).
Le contenu correspondant à Out.txt est "ABCDEFGHIJ", car out.close () est exécuté, qui ferme le flux de sortie; Avant de fermer le flux de sortie, les données de tampon seront écrites dans le flux de sortie.
Remarque: Lorsque vous retestez, supprimez d'abord.txt.
Type 2: Ajoutez l'énoncé suivant avant ReadUserInput ()
out.flush ();
Le but de cette phrase est d'écrire le "contenu tampon" dans le flux de sortie.
(1) Exécutez le programme. Lorsque le programme attend la saisie de l'utilisateur, vérifiez le contenu texte de "out.txt"; Find: Le contenu est "ABCDEFGHIJ".
(2) Exécutez le programme. Après l'entrée de l'utilisateur, vérifiez le contenu texte de "out.txt"; Find: Le contenu est "ABCDEFGHIJ".
À partir de cela, nous avons constaté que le même résultat que (01) et (02), le contenu correspondant de Out.txt est "ABCDEFGHIJ". En effet, l'opération Flush () est effectuée, qui est utilisée pour écrire les données de tampon dans le flux de sortie.
Remarque: Lorsque vous retestez, supprimez d'abord.txt d'abord!
Type 3: en fonction du premier type,
out.write (Arraytters, 0, 10);
Modifié à
out.write (Arraytters, 0, 20);
(1) Exécutez le programme. Lorsque le programme attend la saisie de l'utilisateur, vérifiez le contenu texte de "out.txt"; Découvrez que le contenu est "ABCDEFGHIJKLMNOPQRST" (à l'exclusion de l'entrée).
(02) Exécutez le programme. Après l'entrée de l'utilisateur, vérifiez le contenu texte de "out.txt"; Trouvez que le contenu est "ABCDEFGHIJKLMNOPQRST" (y compris Entrée).
À partir de cela, nous avons constaté que (01) le résultat de l'exécution est "ABCDEFGHIJKLMNOPQRST" (à l'exclusion du rendement du transport). En effet, la taille du tampon est de 16, et nous écrivons 20 octets via Out.Write (Arraytters, 0, 20), dépassant la taille du tampon; À l'heure actuelle, toutes les entrées seront directement écrites dans le flux de sortie sans passer par le tampon.
(3) Le résultat de l'opération est "ABCDEFGHIJKLMNOPQRST" (y compris le retour du chariot), car lors de l'exécution Out.Close (), le symbole de retour du chariot '/ n' est écrit dans le flux de sortie.
Remarque: Lorsque vous retestez, supprimez d'abord.txt d'abord!