Les fonctions d'entrée et de sortie du langage Java sont très puissantes et flexibles, et les opérations d'entrée et de sortie des données sont effectuées de manière "flux". J2SDK fournit une variété de classes "Stream" pour obtenir différents types de données, définies dans le package java.io. Les données sont entrées ou sorties dans le programme via des méthodes standard.
Les flux en Java peuvent être classés sous différents angles:
Selon la direction du flux: il est divisé en flux d'entrée et flux de sortie.
Selon les différentes unités de données: il est divisé en flux d'octets (8 bits) et flux de caractères (16 bits).
Selon les différentes fonctions: divisées en flux de nœuds et en flux de traitement.
Node Flow: est un flux (tel que le fichier, la mémoire) qui peut lire et écrire des données à partir d'une source de données spécifique (nœud). C'est comme un seul tube connecté au robinet et commencer à libérer de l'eau.
Flux de traitement: il est "connecté" sur un flux existant (flux de nœuds ou flux de traitement), offrant au programme des fonctions de lecture et d'écriture plus puissantes via le traitement des données. Tout comme sur la base d'un tuyau (débit de nœud) connecté, quelques tuyaux plus épais et spéciaux (débit de traitement) sont mis sur un traitement supplémentaire de l'eau d'écoulement.
Tous les types de flux fournis par J2SDK situés dans le package java.io Hériter les quatre types de flux abstraits suivants.
Les quatre flux de base InputStream, OutputStream, Reader et Writer ont des sous-classes plus spécifiques, qui sont divisées en flux de fichiers, flux de tampons, flux de données, flux de conversion, flux d'impression, flux d'objets, etc., tous ont des fonctions spécifiques ou sont utilisés pour utiliser des données spécifiques. Parmi eux, les couleurs sombres représentent le flux de nœuds et les couleurs claires représentent le flux de traitement.
Ici, nous résumons l'utilisation spécifique de l'écoulement à travers le flux de nœuds et le flux de traitement.
Classification des flux de nœuds:
Node Streams Process File (fichier), Array (Array in Memory), String (String) et Pipe (Pipe) respectivement.
Classification des flux de traitement:
Les flux de traitement couramment utilisés incluent: le flux de tampon, le flux de conversion, le flux de données, le flux d'objets et le flux d'impression.
Stream tamponné: il doit être porté sur le flux d'octets correspondant et fournit une fonction tampon pour les données de lecture et écrite, ce qui améliore l'efficacité de lecture et d'écriture, et ajoute également des méthodes plus pratiques.
La fonction d'un débit tampon est comme un seau. Le débit d'octets d'origine est un tuyau d'eau. Le tuyau d'eau est directement connecté à la destination. Après avoir ajouté le débit tampon, un seau est connecté sous le tuyau d'eau puis versé dans la destination après que le seau est rempli d'eau. Joue un rôle tampon. De cette façon, vous pouvez lire plus de données à la fois, en évitant la lecture et l'écriture fréquentes sur le disque dur. Comme il a une fonction tampon, vous devez utiliser la méthode Flush lors de l'écriture de données.
importer java.io. *; classe publique TestBuffersTream {public static void main (String [] args) {try {bufferedWriter bw = new BufferedWriter (new FileWriter ("f: //java//io/dat.txt")); // tampon sur le flux Byte sur le fichier écrit BufferedReader Br = New Buffereder (New FileReader ("f: //java//io/dat.txt")); // Stream tamponné sur le flux d'octet sur la chaîne de fichier de lecture s = null; for (int i = 1; i <= 100; i ++) {s = string.valueof (math.random ()); // attribue s à bw.write (s); // Écrit S dans le fichier dat.txt bw.newline (); // Écrivez un caractère de pause de ligne. Une meilleure façon d'utiliser des flux tamponnés consiste à écrire ou à lire une ligne de données. } bw.flush (); // Faire réécrire toutes les données en mémoire immédiatement et plus tamponnées. while ((s = br.readline ())! = null) {// Lisez le contenu du fichier par line system.out.println (s); } bw.close (); // Fermez le flux de traitement et fermez le flux de nœud à l'intérieur. br.close (); } catch (ioException e) {e.printStackTrace (); }}} Convertir le flux: utilisez la conversion avec les données d'octets en données de caractère. Leader InputStreamRed nécessite une prise InputStream, et le sort de sortie de sortie nécessite une prise OutputStream.
Flux de données: DatAnputStream et DataOutputStream fournissent une écriture ou la lecture du type de données de base dans un fichier. Ce flux est très utile. S'il n'y a pas un tel flux, il y a un long qui ne prend que 8 octets. Si je veux écrire dans le fichier, je dois le convertir en une chaîne, puis le convertir en un tableau de caractères, l'espace prendra beaucoup. Cependant, avec ce flux, c'est très pratique. Écrivez simplement ces 8 octets dans le fichier, ce qui enregistre non seulement l'espace mémoire, mais rend également le programme plus pratique et simple. Cependant, vous devez faire attention à la lecture. Selon le type de données que vous lisez, le pointeur se déplacera vers le bas, de sorte que l'ordre que vous lisez doit être cohérent avec l'ordre d'écriture pour répondre à vos besoins corrects. Sinon, cela équivaut à diviser les données.
importer java.io. *; classe publique TestDatastream {public static void main (String [] args) {bytearrayoutputStream baos = new bytearrayoutputStream (); // Créez un flux de nœud. DataOutputStream DOS = new DataOutputStream (BAOS); // Connectez un flux de données "tuyau" sur le flux de nœud essayez {dos.writedouble (math.random ()); // Double type, 8 octets dos.writeboolean (true); // Boolean Type, occupe un bytebytearrayInputStream Bais = new ByteArrayInputStream (Baos.ToByteArray ()); System.out.println (bais.available ()); // Nombre total d'octets disponibles dans le flux de sortie - 9 DatainputStream dis = new DataRainputStream (BAIS); // Connectez également le flux de données "tuyau" en dehors du flux de sortie System.out.println (dis.readouble ()); // Lisez tourné le numéro de type double System.out.println (dis.readboolean ()); // Lisez tourné le type booléen dos.close (); divulguer(); } catch (ioException e) {e.printStackTrace (); }}}
Stream d'impression: Java.io fournit des flux d'impression. Ce type de flux a la fonction de rinçage automatique lors de l'écriture, il n'est donc pas nécessaire de rincer chaque fois que vous imprimez quelque chose.
importer java.io. *; classe publique TestPrintStream1 {public static void main (String [] args) {printStream ps = null; essayez {fileoutputStream fos = new FileOutputStream ("f: //java//io/log.dat"); // Créez le flux de sortie et spécifiez l'emplacement de sortie ps = new printStream (fos); // Package le flux d'impression à l'extérieur du flux} catch (ioException e) {e.printStackTrace (); } if (ps! = null) {System.SetOut (ps); // Définissez l'impression du système sur le flux d'impression ps} int ln = 0; pour (char c = 0; c <= 60000; c ++) {System.out.print (C + ""); // N'imprime pas à la fenêtre DOS, le flux de sortie est imprimé directement dans le fichier spécifié if (ln ++> = 100) {System.out.println (); ln = 0; }}}}