Stream Io
En Java, les flux IO sont divisés en deux types: les flux d'octets et les flux de caractères. Comme son nom l'indique, les flux d'octets sont lus et écrits selon les octets, et les caractères sont accessibles en fonction des caractères; La lecture de fichiers couramment utilisée est un flux de caractères et les flux d'octets sont utilisés dans la communication réseau.
Le chiffre suivant est le cadre global des flux IO en Java:
Ruisseau d'octets
En Java, les ruisseaux d'octets se terminent généralement par des flux. Le flux d'octet d'entrée est appelé InputStream, et le flux d'octet de sortie est appelé outputStream; InputStream et OutputStream sont des superclasses représentant toutes les classes de leur entrée / sortie, et sont des classes abstraites (abstraites)
Les flux d'octets couramment utilisés sont:
1.FileInputStream / FileOutputStream2.BufferedInputStream / BufferedOutputStream3.SenceInputStream (Séquence Stream) 4.ObjectInputStream / ObjectOutStream (Entrée d'objet et flux de sortie) 5.PrintStream (Stream d'impression)
Flux de personnage
Dans Java, le flux de caractères d'entrée se termine par lecteur, et le flux de caractères de sortie se termine par l'écrivain. Par exemple, notre FileReader et FileWriter communs sont des flux de caractères, et Reader et Witer sont des superclasses de flux de caractères d'entrée / sortie, et sont également des classes abstraites.
Les flux de caractères couramment utilisés sont:
1.FileReader / FileWriter2.BufferedReader / BufferedWriter3.InputStremReader / OutputStreamWriter (Convert Stream)
Convertir le flux
Un flux de conversion est une classe qui convertit un flux d'octets en flux de caractères, et il existe deux types:
・ InputStreamReader ・ OutputStreamwriter
InputStreamReader est un flux de caractères (lecteur), qui nécessite l'emballage d'un flux d'octets (InputStream);
OutputStreamWriter est un flux de caractères (écrivain) et doit envelopper un flux d'octets (OutputStream)
Décorer
Le but de l'emballage est d'ajouter de nouvelles fonctions sur la base de l'objet d'origine. Par exemple, le BufferedReader enveloppe un lecteur, qui est en fait une amélioration de la fonction du lecteur; Le lecteur d'origine ne peut être lu que par un seul caractère et un caractère, et le BufferedReader formé après l'emballage a une nouvelle fonction: la fonction de lire directement une ligne (Readline). Intuitivement parlant, c'est la soi-disant décore.
En termes de mode de conception, il s'agit d'un mode décoratif typique, et ses caractéristiques sont:
1. Les objets décoratifs et les objets réels ont la même interface. De cette façon, l'objet client peut interagir avec l'objet décoratif de la même manière que l'objet réel. 2. L'objet décoratif peut ajouter des fonctions supplémentaires avant ou après le transfert de ces demandes. Cela garantit que pendant l'exécution, des fonctions supplémentaires peuvent être ajoutées à l'extérieur sans modifier la structure de l'objet donné.
Correspond à nous est que BufferedReader et Reader sont les deux lecteurs. Après emballage, la fonction BufferedReader est améliorée, mais elle peut toujours être utilisée comme lecteurs (la référence de la classe des parents d'OO peut pointer des sous-classes)
exemple
Exemple de flux d'octets
Coupez le fichier MP3 en plusieurs copies et recombinez-le
Package cn.xdian.test; import java.io.file; import java.io.fileInputStream; import java.io.fileoutputStream; import java.io.ioException; import java.io.senceInputstream; import java.util.enumeration; import java.util. lance ioException {cutFile (); // Cut Mp3 Fichier Mergeflile (); // Merge Files MP3} // Merge Mp3Public Static void Mergeflile () lance ioException {file Diir = nouveau fichier ("/ home / gavinzhou / music_test"); // fin tous les fichiers MP3 dans le dossier Vector <FileInPutStream> Vector = Vecteur = new Vector <FichierInputStream> (); file [] files = dir.listFiles (); pour (fichier de fichier: fichiers) {if (file.getName (). Endswith (". mp3")) {vector.add (new FileInputStream (fichier));}} // obtenez l'itérateur via Vector Enumeration <FeleInputStream> E = Vector.Elements (); // Créer une séquence de StreamInputStream Entream = New SequenceInputStream (E); FileOutputStream fileoutputStream = new FileOutputStream ("/ home / gavinzhou / conbine.mp3"); // lire le fichier mp3 divisé byte [] buf = new byte [1024]; int length = 0; while ((longueur = inputStream.read (buf))! = - 1) {FileOutStream.write (buf, 0, longueur);} fileoutputStream.close (); inputStream.close ();} // coupe mp3Public static void cutFile () lève ioException {file file = new File ("/ home / gavinzhou / music_test"); FileInputStream (fichier); // Lire le fichier byte [] buf = new byte [1024 * 1024]; int length = 0; for (int i = 0; (longueur = fileInputStream.read (buf))! = - 1; i ++) {fileoutputStream fileoutStream = new FileOutStream (new File (dir, "part" + i + ". Mp3")); fileoutputStream.write (buf, 0, longueur); fileoutputStream.close ();} // fermer le flux fileInputStream.close ();}}Exemple de flux de caractères
Copier le fichier A pour fichier b
Package CN.Xidian.test; Importer java.io.bufferedReader; Importer java.io.botteredWriter; Importer java.io.file; import java.io.fileReader; import java.io.filewriter; String java.io.ioexception; public class Demo1 {public static Void Main (String [] args) throws ioexception {Public Static Void Main (String [] args) throws ioexception {Public Static Void Main (String [] args) throws ioexception {Public Static Void Main (String [] args) Throws Ioexception {Public Static Void Main (String [] Args) Throws Ioexception {Public Static Void Main (String. Fichier ("/ home / gavinzhou / a.txt"); fichier DesFile = new File ("/ home / gavinzhou / b.txt"); // crée le flux de bilans d'entrée BuffereDer Input = new BufferedReader (new FileReader (SourceFile)); // Créer le Stree Stream BufferedWriter Output = New BufferedWriter (New FileWriter (DESFILE)); line = null; while ((line = input.readline ())! = null) {output.write (line); output.newline ();} // Fermez le flux d'entrée et de sortie Input.close (); output.close ();}}Exemple de flux d'impression
Le package cn.xidian.test; import java.io.file; import java.io.fileoutputStream; import java.io.ioexception; import java.io.printstream; / * le flux d'impression peut imprimer tout type de données. Avant d'imprimer les données, les données seront converties en une chaîne puis imprimées * / class animal {String name; String colore; public animal (String Name, String Color) {this.name = name; this.color = colore;} @ override public String toString () {return "name:" + this.name + "coloride: this.color;}} args) lance ioException {/ * file file = new File ("/ home / gavinzhou / a.txt"); // Créer un Stream Print Stream PrintStream PrintStream = new PrintStream (fichier); // imprime toutes les informations dans le fichier printStream.println (97); printStream.println (3.14); printstream.println ('a'); printStream.println (true); Animal a = nouvel animal ("rat", "noir"); printstream.println (a); // modifie le système d'entrée et de sortie standard.Setout (printStream); // La sortie standard se situe à l'écran System.out.println ("test ...."); * /// Collection d'informations sur le journal des exceptions. File LogFile = nouveau fichier ("/ home / gavinzhou / test.log"); printStream logprintStream = new PrintStream (new FileOutputStream (logfile, true)); try {int c = 4/0; // créer une exception system.out.println ("c =" + c); int [] arr = null; System.out.trintln (arr.Length); e) {e.printStackTrace (logprintStream); // sortie à fichier plutôt que sur l'écran}}}}Résumer
Ce qui précède concerne l'analyse des flux IO et les exemples de code en Java. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à ce site:
Exploration Java: Exemples de code cryptés et décryptés de fichiers thread + io
Analyse du code de connaissances lié au flux Java IO
Interprétation détaillée du flux Java IO
S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!