Flux de sortie du flux d'entrée Java

1. Qu'est-ce que IO

Les opérations d'E/S en Java font principalement référence à l'utilisation de Java pour les opérations d'entrée et de sortie. Tous les mécanismes d'E/S en Java sont basés sur. Les flux de données effectuent des entrées et des sorties. Ces flux de données représentent une séquence fluide de caractères ou d'octets. Les flux d'E/S Java fournissent des méthodes standard pour lire et écrire des données. Tout objet représentant une source de données en Java fournira des méthodes pour lire et écrire ses données dans un flux de données.

Java.io est le package principal pour la plupart des classes d'entrée/sortie orientées flux de données. De plus, Java prend également en charge la transmission par blocs et le bloc IO est utilisé dans la bibliothèque principale java.nio.

L'avantage du stream IO est qu'il est simple et facile à utiliser, mais l'inconvénient est qu'il est moins efficace. Le bloc IO est très efficace, mais la programmation est plus compliquée.
Java IOModèle :
La conception du modèle IO de Java est très excellente. Elle utilise le mode Décorateur pour diviser les flux par fonction. Vous pouvez assembler dynamiquement ces flux pour obtenir votre. fonctionnalité requise. Par exemple, si vous avez besoin d'un flux d'entrée de fichier mis en mémoire tampon, vous devez utiliser une combinaison de FileInputStream et BufferedInputStream.

Concepts de base du flux de données

Le flux de données est une collection de données continues, tout comme le débit d'eau dans une conduite d'eau, l'eau est fournie petit à petit à une extrémité de la conduite d'eau , et dans la conduite d'eau. Ce que vous voyez à l'autre extrémité est un jet d'eau continu. Le programme d'écriture de données peut écrire des données dans le pipeline de flux de données segment par segment. Ces segments de données formeront un long flux de données en séquence. Pour les programmes de lecture de données, la segmentation du flux de données pendant l'écriture ne peut pas être vue à chaque fois, mais seules les données précédentes peuvent être lues en premier, puis les données suivantes. Que les données soient écrites en plusieurs lots ou écrites dans leur ensemble en une seule fois, l'effet lors de la lecture est exactement le même.

"Un flux est la source ou le point final des données stockées sur un disque ou d'autres périphériques

Il existe trois façons de stocker des données sur un ordinateur, l'un est le stockage externe, l'un est la mémoire et l'autre est le cache. Par exemple, le disque dur, le disque magnétique, la clé USB, etc. de l'ordinateur sont tous des stockages externes. Il y a une clé USB sur l'ordinateur et le cache est dans le processeur. Le stockage externe a la plus grande capacité de stockage, suivi de la mémoire et enfin du cache. Cependant, la lecture des données du stockage externe est la plus lente, suivie de la mémoire et du cache la plus rapide. Voici un résumé de la lecture des données de la mémoire externe vers la mémoire et de l'écriture des données de la mémoire vers la mémoire externe. Pour comprendre la mémoire et le stockage externe, nous pouvons simplement la comprendre comme un conteneur, c'est-à-dire que le stockage externe est un conteneur et la mémoire est un autre conteneur. Alors, comment lire les données du conteneur de stockage externe dans le conteneur de mémoire et comment enregistrer les données du conteneur de mémoire sur un stockage externe ?

Dans la bibliothèque de classes Java , le contenu de la partie IO est très vaste car il couvre un large éventail de champs :

Entrée standard et sortie, opérations sur les fichiers, flux de données sur le réseau, flux string, flux d'objets, zipflux de fichiers, etc., L'abstraction d'entrée et de sortie en Java est appelée un ruisseau, tout comme une conduite d'eau, reliant deux récipients. La lecture de données de la mémoire externe vers la mémoire est appelée flux d'entrée, et l'écriture de données de la mémoire vers la mémoire externe est appelée flux de sortie.

Stream est un concept très vivant. Lorsque le programme a besoin de lire des données, il ouvrira un flux vers la source de données. Cette source de données peut être un fichier, une mémoire ou une connexion réseau. De même, lorsque le programme doit écrire des données, il ouvrira un flux vers la destination.

Les concepts de base résumés sont les suivants :

1) Flux de données :

Un ensemble ordonné de Séquence de données des octets de début et de fin. Y compris le flux d’entrée et le flux de sortie.

2) Flux d'entrée (Flux d'entrée) :

Le programme lit la source de données à partir du flux d'entrée. Les sources de données incluent le monde extérieur (clavier, fichiers, réseau...), qui est le canal de communication qui lit la source de données dans le programme

3) Flux de sortie  :

Le programme écrit des données dans le flux de sortie. Un canal de communication qui transmet les données du programme vers le monde extérieur (moniteur, imprimante, fichier, réseau...).

Le but de l'utilisation du flux de données est de rendre la sortie et l'entrée indépendantes de l'appareil.

Input Stream ne se soucie pas de l'appareil d'où proviennent la source de données (clavier, fichier, réseau)
Output Stream ne se soucie pas de l'appareil auquel les données sont destinées (clavier, fichier, réseau)

4 Classification du flux de données :

Les données de la séquence de flux peuvent être soit des données binaires originales non traitées, soit des données spécifiques conformes à un certain format après un certain encodage. Il existe donc deux types de flux en Java :
1) Flux d'octets : La plus petite unité de données dans le flux de données est l'octet
2) Flux de caractères : données La plus petite unité de données du flux est un caractère. Les caractères en Java sont codés en Unicode et un caractère occupe deux octets.

3. >

Les programmes Java peuvent brièvement échanger des informations avec le monde extérieur via des paramètres de ligne de commande. En même temps, ils permettent également l'échange d'informations avec des périphériques d'entrée et de sortie standard, tels que. comme les claviers et les moniteurs. Grâce aux fichiers, des informations sous n'importe quelle forme de données peuvent être échangées avec le monde extérieur.

1. Paramètres de ligne de commande

1. public class TestArgs { 

2. public statique void main(String[ ] args) {

3.  

   pour (int i = 0; i < args.length; i++) {

4. System.out.

   println("args[" + i + "] est <" + args[i] + ">");

} 
} 

Exécuter la commande : Java Java C VB

Résultat de l'exécution :

args[0] est

args[1] est

args[ 2] est

2. Flux de données d'entrée et de sortie standard

Le flux de données standard fourni avec le système Java : java.

lang

.System :

java.lang.System 
2. public

   final class System étend Objet{

3. erreur PrintStream statique;

   //Flux d'erreur standard (sortie)

4. static InputStream in;

   //Entrée standard (flux d'entrée clavier)

5. static PrintStream out;

   //Standard output Stream ( flux de sortie du moniteur)

}

Remarque :
(1) La classe System ne peut pas créer des objets et ne peut utiliser que ses trois membres statiques directement.
(2) Chaque fois que la méthode principale est exécutée, les trois objets ci-dessus sont automatiquement générés.

1) Flux de sortie standard System.out

System.out génère des données vers le périphérique de sortie standard , son type de données est pour PrintStream. Méthode :

Void print(paramètre)

Void println(paramètre)

2) Flux d'entrée standard System.in

System.in lit les données du périphérique d'entrée standard (obtient les données à partir de l'entrée standard, généralement le clavier), et son type de données est InputStream. Méthode :

int read() //Renvoie le code ASCII. Si la valeur de retour = -1, cela signifie qu'aucun octet n'a été lu et que le travail de lecture est terminé.

int read(byte[] b)//Lire plusieurs octets dans le tampon b La valeur de retour est le nombre d'octets lus

Par exemple :

1. importer java.io.*

2. public class StandardInputOutput {

3. public static void main(String args[]) {

4. int b;

5. essayez {

System.out.println(
6. "veuillez saisir :");

((b = System.in.read()) != -
7. 1) {

   System.out.print((char ) b); 

8.                                                    🎜>

9. System.out.println(e.toString());

10. }

    } 

11. } 

En attente de saisie au clavier, quelle que soit la saisie au clavier est imprimé :
3) Flux d'erreurs standard

System.err génère la norme erreur

, son type de données est PrintStream. Veuillez vous référer à l'

API

pour des instructions détaillées.

La sortie standard appelle la méthode println via System.out pour afficher les paramètres et envelopper les paramètres, tandis que la méthode d'impression affiche les paramètres mais n'enveloppe pas la ligne. La méthode println ou print implémente plusieurs méthodes de sortie de types de données de base via

surcharge , y compris les types de paramètres de sortie boolean, char, int, long, float

et double. Dans le même temps, les méthodes dont les types de paramètres de sortie sont char[], String et Object sont également surchargées. Parmi elles, les méthodes print(Object) et println(Object) appelleront la méthode toString du paramètre Object au moment de l'exécution.

importer java.io.BufferedReader

importer java.io.IOException;

1. importer java.io.InputStreamReader ; >public

   class StandardInputOutput { 🎜>statique
void main(String args[]) {

3. Chaîne s;

4. InputStreamReader ir =

nouveau
5. InputStreamReader(System.in);

   BufferedReader in =

   new BufferedReader( ir);

6. System.out.println(

   "Système Unix : ctrl-d ou ctrl-c
Quitter
7. "

                                                                                              🎜>

                                                                                                                                                                                      >()

8.                                                                                                             >

    
while (s !=

9. null) {

10.        System.out.println("Lire : " + s);

11. s = in.readLine(); in.close();

12. } catch (IOException e) { // Attrape toutes les exceptions IO

13. 🎜>                                                                                            

15. Architecture hiérarchique 4.java.IO

Les éléments les plus importants de l'ensemble du package Java.io sont 5 classes et une
16. interface

    . Les cinq classes font référence à File, OutputStream, InputStream, Writer et Reader ; une interface fait référence à Seriallessly. Une fois que vous maîtriserez ces opérations IO de base, vous aurez une compréhension préliminaire du système IO en Java

17. Java I/O comprend principalement les niveaux suivants, comprenant trois parties :

1. Partie streaming
18. —IO La partie principale

2. La partie non-streaming
19. - comprend principalement certaines classes qui assistent la partie streaming, telles que : la classe File, la classe RandomAccessFile et la classe FileDescriptor

    3. classes--classes liées à la sécurité

    dans la partie lecture des fichiers, telles que : classe SerializingPermission et
système de fichiersClasses, telles que : Classe FileSystem et classe Win32FileSystem et classe WinNTFileSystem.

20. Les principales catégories sont les suivantes :

1. Fichier (caractéristiques et gestion des fichiers) : utilisé pour les informations de description des fichiers ou des répertoires, telles que la génération de nouveaux répertoires, la modification des noms de fichiers,
21. supprimer

    Fichier, déterminer le chemin du fichier, etc.

    2. InputStream (opération au format binaire) : Classe abstraite, opération d'entrée basée sur les octets, est la classe parent de tous les flux d'entrée. Définit les caractéristiques communes que possèdent tous les flux d’entrée.

    3. OutputStream (opération au format binaire) : classe abstraite. Opérations de sortie basées sur les octets. Est la classe parent de tous les flux de sortie. Définit les caractéristiques communes à tous les flux de sortie.

    Les caractères en Java adoptent la norme Unicode. Un caractère fait 16 bits, c'est-à-dire qu'un caractère est représenté par deux octets. À cette fin, des flux de traitement des caractères ont été introduits en JAVA.

    4. Lecteur (opération de format de fichier) : classe abstraite, opération de saisie basée sur les caractères.

    5. Writer (opération de format de fichier) : classe abstraite, opération de sortie basée sur les caractères.

    6. RandomAccessFile (opération de fichier aléatoire) : il possède des fonctions riches Vous pouvez effectuer des opérations d'accès (entrée et sortie) à partir de n'importe quel emplacement du fichier.

    L'architecture du flux IO en Java est telle que montrée dans la figure :

    

    
    

    
    Dans le package java.io du langage Java, la classe File fournit des opérations et des méthodes de gestion pour décrire les fichiers et les répertoires. Cependant, la classe File n'est pas une sous-classe d'InputStream, OutputStream ou Reader ou Writer, car elle n'est pas responsable de l'entrée et de la sortie des données, mais est spécifiquement utilisée pour gérer les fichiers et répertoires du disque.

    Fonction : La classe File est principalement utilisée pour nommer des fichiers,
    interroger

    fichiers

    attributs

    et

    traiter des fichiers
    répertoires.

    public 

    class File étend l'objet 
    

    implémente Sérialisable, Comparable
    

    1. {}

    2. La classe File fournit un total de trois

       constructeurs différents pour recevoir de manière flexible des informations sur les noms de fichiers et de répertoires sous différentes formes de paramètres. Constructeur :

       1) Fichier (nom du chemin de la chaîne)

    3. Exemple : File f1=new File("FileTest1.txt"); //Créer un objet fichier f1, pointé par f1 Le Le fichier est créé dans le répertoire courant FileTest1.txt

    2) Fichier (String parent, String enfant)

    
    Exemple : Fichier f2=new File("D:\

    dir

    1","FileTest2.txt") ;// Remarque : Le répertoire D:\dir1 doit exister au préalable, sinon une exception se produira

    3) Fichier (Fichier parent , String enfant) Exemple : File f4=new File("\dir3");
    File f5=new File(f4,"FileTest5.txt"); //Si le répertoire \dir3 n'existe pas, utilisez f4.mkdir() Créez d'abord Une fois un objet File correspondant à un fichier ou répertoire disque créé, vous pouvez obtenir les attributs du fichier ou du répertoire en appelant sa méthode.

    1) public boolean exist() Détermine si le fichier ou le répertoire existe
    2) Public boolean isFile() Détermine s'il s'agit d'un fichier ou d'un répertoire 3) Public boolean isDirectory() Détermine si c'est un fichier ou un répertoire 4) public String getName() renvoie le nom du fichier ou du répertoire

    5) public String getPath() renvoie le chemin du fichier ou du répertoire.

    6) public long length( ) Obtenez la longueur du fichier 7) public String[ ] list ( ) Enregistrez tous les noms de fichiers du répertoire dans la chaîne tableau
    et renvoyez-le. La classe File définit également certaines méthodes de gestion et d'exploitation de fichiers ou de répertoires. Les méthodes couramment utilisées sont :
    1) public boolean renameTo(File newFile); 🎜>delete
    ( ); Supprimer le fichier

    3) public boolean mkdir( ); Créer un répertoire

    
    Exemple :
    

    
    

    
    

    1. importer java.io.File

    2. importer java.io.IOException

    3. public class TestFile { 🎜>

    public
    4. statique

       void main(String args[]) lance IOException {

       Fichier dir =
    nouveau fichier(
    5. "\root");
       Fichier f1 =
    nouveau fichier(dir,
    6. "fileOne.txt");
       fileTwo.java");
                                                                                                                                  >

    8.  if (!f1.exists()) 

    9.                                                                                                                           🎜>                                                                                                     System.out.println( "f1's AbsolutePath= " + f1.getAbsolutePath());

    10. System.out.println(

        " f1Canread= " + f1.canRead());

    11. System.out.println(

        "f1's len= " + f1.length()); 🎜>

    12. String[] FL;

    13. int count

        =
    0 >
    FL = dir.list();

    15. pour (
    int i =
    16. 0; i < FL.length; i++ ) {

    17. count++

    System.out.println( FL[i] +
    18. "est dans \root");

    19. "il y a" + compte + "fichier dans //root"); 🎜>}

    21. Description : Méthodes de classe de fichier : (1) exist() Teste si le fichier ou le répertoire spécifié existe sur le disque (2) mkdir() Crée le répertoire spécifié par l'objet fichier (répertoire monocouche) (3) createNewFile( ) Créez le fichier spécifié par l'objet fichier (4) list() renvoie toutes les chaînes de nom de fichier dans le répertoire

    23. 6. Bibliothèque de classes de flux Java.IO

    1. Quatre classes de base de flux io

    24. Le package java.io contient les exigences pour le streaming des E/S de toutes les classes. Il existe quatre classes de base dans le package java.io : les classes InputStream, OutputStream et Reader et Writer, qui gèrent respectivement les flux d'octets et les flux de caractères :

    25. Flux de données de base I/ O

        
        

        Entrée/Sortie

        输入/输出	字节流	字符流
        输入流	Inputstream	Reader
        输出流	OutputStream	Writer

        Flux d'octets<🎜>

        Flux de caractères<🎜>

        Flux d'entrée<🎜>

        Flux d'entrée<🎜>

        Lecteur<🎜>

        Flux de sortie<🎜>

        OutputStream <🎜>

        Écrivain<🎜>

        
        

        Une variété d'autres flux en Java en sont dérivés :

        

        

        

        

        La version JDK1.4 a introduit une nouvelle bibliothèque de classes d'E/S, située dans java Dans le . nio, la nouvelle bibliothèque de classes d'E/S utilise des canaux et des tampons pour améliorer l'efficacité des opérations d'E/S.

        Dans le package java.io, java.io.InputStream représente le flux d'entrée d'octets et java.io.OutputStream représente le flux de sortie d'octets, qui se trouve au niveau supérieur du package java.io. Les deux classes sont des classes abstraites, ce qui signifie qu’elles ne peuvent pas être instanciées et doivent être sous-classées pour réaliser certaines fonctions.

        1. Classification spécifique des flux io

        1. Classification globale par type d'E/S :

        <.> 1. Mémoire 1) Lire les données depuis/vers le tableau mémoire de données : char Array Reader, CharArrayWriter, bytearrayinPutstream, bytearrayoutstream 2) Lire et écrire des données StringReader, StringWriter, StringBufferInputStream
        
        2.Pipe pipeline Implémenter l'entrée et la sortie du pipeline (communication inter-processus) : PipedReader, PipedWriter, PipedInputStream, PipedOutputStream
        3.File file Flux. Lire et écrire des fichiers : FileReader, FileWriter, FileInputStream, FileOutputStream
        4. Entrée et sortie de l'objet ObjectSerialization : ObjectInputStream, ObjectOutputStream
        5.DataConversion flux de données Appuyez sur le type de données de base. lecture et écriture (les données traitées sont les types de base de Java (tels que booléen, octet, entier et nombre à virgule flottante)) : DataInputStream, DataOutputStream
        6.Impression Contient une impression pratique méthodes : PrintWriter, PrintStream
        7.Buffering Mettre en cache les données lors de la lecture ou de l'écriture pour réduire le nombre d'E/S : BufferedReader, BufferedWriter, BufferedInputStream, BufferedOutputStream
        8.Filtering Filtrage, filtrage lorsque les données sont lues ou écrites : FilterReader, FilterWriter, FilterInputStream, FilterOutputStream via
        9.Entrée de concaténation Connectez plusieurs flux d'entrée en un seul flux d'entrée : SequenceInputStream
        10. Comptage Comptage Compter les lignes lors de la lecture des données : LineNumberReader, LineNumberInputStream
        11. >12.Conversion entre octets et caractères Convertissez le flux d'octets en flux de caractères selon certaines normes d'encodage/décodage, ou effectuez une conversion inverse (classe de conversion de Stream en Reader, Writer) : InputStreamReader, OutputStreamWriter
        2. Classification par source de données (destination) :

        1. Fichier (fichier) : FileInputStream , FileOutputStream, FileReader, FileWriter

        2 octet[] : ByteArrayInputStream, ByteArrayOutputStream 3. . Char[]: CharArrayReader, CharArrayWriter 4. String: StringBufferInputStream, StringReader, StringWriter
        5.Flux de données réseau：InputStream, OutputStream, Reader, Writer
        
        
        
        

        
        

        7. Flux d'octets InputStream /OutputStream

        
        

        1. InputStream

        Classe abstraite

        InputStream est un flux d'entrée d'octets. C'est elle-même une classe abstraite et doit s'appuyer sur ses sous-classes. Implémentant diverses fonctionnalités, cette classe abstraite est la superclasse de toutes les classes qui représentent des flux d'entrée d'octets. Les flux qui héritent de InputStream sont utilisés pour saisir des données dans le programme, et l'unité de données est l'octet (8 bits) ;

        InputStream est une classe pour saisir des données d'octets, donc la classe InputStream fournit trois méthodes de lecture surchargées. Méthodes courantes dans la classe Inputstream :
        (1) public abstract int read() : Lire un octet Les données, le retour. value est une valeur de type int avec les bits hauts remplis par 0. Si la valeur de retour = -1, cela signifie qu'aucun octet n'a été lu et que le travail de lecture est terminé.
        (2) public int read(byte b[ ]) : lit les octets de données b.length et les place dans le tableau b. La valeur de retour est le nombre d'octets lus. Cette méthode est en fait implémentée en appelant la méthode suivante
        (3) public int read(byte b[ ], int off, int len) : lit jusqu'à len octets de données du flux d'entrée et les stocke dans le décalage dans le tableau b dont le montant du décalage est désactivé.
        　(4) public int available() : renvoie le nombre d'octets pouvant être lus dans le flux d'entrée. Remarque : Si l'entrée est bloquée, le thread en cours sera suspendu. Si l'objet InputStream appelle cette méthode, il ne retournera que 0. Cette méthode doit être appelée par un objet de sous-classe qui hérite de la classe InputStream pour être utile
        . (5) public long skip(long n) : ignore n octets dans le flux d'entrée. La valeur de retour est le nombre d'octets réellement ignorés.
        (6) public int close() : nous finissons d'utiliser. Enfin, le flux que nous avons ouvert doit être fermé.

        Sous-classes principales :

        

        1) FileInputStream utilise un fichier comme InputStream pour implémenter l'opération de lecture de fichier
        2) ByteArrayInputStream : Utiliser un tampon en mémoire comme InputStream
        3) StringBufferInputStream : Utiliser un objet String comme InputStream
        4) PipedInputStream : Implémenter le concept de pipe, principalement dans les threads Utiliser
        5) SequenceInputStream : fusionner plusieurs InputStreams en un seul InputStream

        2. OutputStreamClasse abstraite

        OutputStream fournit 3 méthodes d'écriture pour la sortie des données, ce qui correspond à InputStream.
        1. public void write(byte b[ ]) : Écrivez l'octet du paramètre b dans le flux de sortie.
        2. public void write(byte b[ ], int off, int len) : Écrivez len octets du paramètre b en commençant par offset off dans le flux de sortie.
        　3. public abstract void write(int b) : convertissez d'abord int en type octet et écrivez l'octet de poids faible dans le flux de sortie.
        　4. public void flush( ) : affiche toutes les données dans le tampon de données et efface le tampon.
        　5. public void close() : ferme le flux de sortie et libère les ressources système liées au flux.

        Sous-classes principales :

        

        1) ByteArrayOutputStream : stocker les informations dans un tampon en mémoire
        2) FileOutputStream : stocker les informations enregistrées dans un fichier
        3) PipedOutputStream : implémente le concept de pipe, principalement utilisé dans les threads
        4) SequenceOutputStream : fusionne plusieurs OutStreams en un seul OutStream

        Détermination de la fin du flux : méthode read Lorsque la valeur de retour de () est -1 ; lorsque la valeur de retour de readLine() est nulle.

        3. Flux d'entrée de fichier : classe FileInputStream

        FileInputStream peut utiliser la méthode read() pour lire un octet à la fois et le renvoyer sous forme de type int, ou le lire en utilisant read( ) Dans un tableau d'octets, combien d'octets sont lus car il y a des éléments dans le tableau d'octets. Lors du processus de lecture ou d'écriture de l'intégralité du fichier, un tel tableau d'octets est généralement utilisé comme tampon, car un tel tableau d'octets joue généralement un rôle intermédiaire dans la réception des données.

        

        Fonction : Utiliser le fichier as a Le flux de données pour la source d'entrée de données. En d’autres termes, c’est une classe qui ouvre un fichier et lit les données du fichier en mémoire.
        Utilisation (1)
        File fin=new File("d:/abc.txt");
        FileInputStream in=new FileInputStream( fin);

        Méthode d'utilisation (2)
        FileInputStream in=new FileInputStream(“d: /abc.txt”);

        Exemple de programme :
        Afficher le contenu du programme InputFromFile.java sur le moniteur

        

        
        

        1. importer java.io.IOException

        2. importer java.io.FileInputStream ;  

        3. ;  

        4. public class TestFile {  

        5.     public statique void main(String args[]) lance IOException {  

        6.         essayer{      

        7.                FileInputStream rf=new   FileInputStream("InputFromFile.java");  

        8.                int n=512 ;   octet  buffer[]=nouveau  octet[n] ;     

        9.               while((rf.read(buffer,0,n)!=-1)&&(n>0)){  

        10.                    System.out.println(new String (tampon) );  

        11.                 }  

        12.                 System.out.println();  

        13.                 rf.close();  

        14.         } catch(IOException  IOe){        

        15.                System.out.println(IOe.toString());  

        16.         }  

        17. 
            

        18.     }  

        19. 
            

        20. }  

        
        

         

        4.文件输出流:FileOutputStream类

        　  作用：用来处理以文件作为数据输出目的数据流；或者说是从内存区读数据入文件

         

              FileOutputStream File或FileDescriptor对象。 
        　创建一个文件流对象有两种方法： 
        　　方式1 ： 
        　　 Fichier   f=new  File ("d:/myjava/write.txt ");
                FileOutputStream  out= new FileOutputStream (f);
        　　方式2： 
        　　FileOutputStream out=new FileOutputStream( " d:/myjava/write.txt "); 
        　方式3：构造函数将 FileDescriptor()对象作为其参数。 
        　　FileDescriptor() fd=new FileDescriptor(); 
        　　FileOutputStream f2=new FileOutputStream(fd); 
        　　方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。 
        　　FileOutputStream f=new FileOutput Stream("d:/abc.txt",true); 
        　　注意： (1)文件中写数据时，若文件已经存在，则覆盖存在的文件；（2)的读/写操作结束时，应调用close方法关闭流。 

         

        
        

        程序举例：使用键盘输入一段文章，将文章保存在文件write.txt中

        

        
        

        
        

        1. importer java.io.IOException ;  

        2. importer java.io.FileOutputStream ;  

        3. public class TestFile {  

        4.     public  static void main(String args[]) lance IOException {  

        5.                                                                                                                                                                           🎜>

                                                                                                                ] =
        nouveau
        6. octet[n]

        7. count = System.in.read(buffer); FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt"); 🎜>

        8. wf write(buffer, 0, count); wf.close(); 🎜>// Une fois l'opération d'écriture du flux terminée, appelez la méthode close pour fermer le flux .

        9. System.out.println(
        "Enregistrer dans le write.txt");

        10. } catch (IOException IOe) {

        11. System.out.println("Erreur d'écriture de fichier!");

        12. }                                                                                            >

        13. 5. Application de FileInputStream et FileOutputStream

            Utilisez le programme pour copier le fichier file1.txt dans file2. .SMS.

        15. importer java.io.File

        16. importer java.io.IOException ;

        importer java.io.FileOutputStream ; 🎜>importer java.io.FileInputStream ; >

        18. 
            

            public
        statique
        19. void main(String args[])

            lance IOException {

        
        

        essayez {

        
        

        
        Fichier inFile =

        nouveau fichier(
        "
        1. copie

           .java") ; >

        2. FileInputStream finS =

           new FileInputStream(inFile);

        3. FileOutput Stream foutS =

           new FileOutputStream(outFile);

        4.  

           int c; finS .read()) != -1) {

        5. 
           foutS.write(c);

        6.                                                                                                               

        7. foutS.close();

        8. } catch (IOException e) { 🎜>       System.err.println("FileStreamsTest : " + e);

        10. }

        12. 
            

        6. >

        13. L'accès à des périphériques externes prend beaucoup de temps à l'ordinateur. Plus la fréquence d'accès à la mémoire externe est élevée, plus la probabilité que le processeur soit inactif est grande. Afin de réduire le nombre d'accès à la mémoire externe, davantage de données doivent être lues et écrites en un seul accès au périphérique. À cette fin, en plus des mécanismes de lecture et d'écriture nécessaires à l'échange de données entre programmes et nœuds de flux, un mécanisme de mise en mémoire tampon doit également être ajouté. Le flux tampon signifie que chaque flux de données se voit attribuer un tampon, et un tampon est une mémoire qui stocke temporairement les données. Cela peut réduire le nombre d'accès au disque dur et améliorer l'efficacité de la transmission.

        
        BufferedInputStream : lors de l'écriture de données dans le flux mis en mémoire tampon, les données sont d'abord écrites dans le tampon. Lorsque le tampon est plein, le système envoie les données au périphérique de sortie en une seule fois.

        BufferedOutputStream : lors de la lecture des données du flux mis en mémoire tampon, le système lit d'abord les données du tampon. Lorsque le tampon est vide, le système lit ensuite les données du périphérique d'entrée dans le tampon.

        
        1) Lire le fichier en mémoire :

        

        Connectez BufferedInputStream à FileInputStream

        
        FileInputStream in= new FileInputStream ( « file1.txt » );

        BufferedInputStream bin=new BufferedInputStream( in);

        
        2) Écrire la mémoire dans le fichier :

        Connecter BufferedOutputStream avec FileOutputStream
        FileOutputStreamout=new FileOutputStream(“file1.txt”);
        BufferedOutputStream bin=new BufferedInputStream(out);

        3) Lire le flux d'entrée du clavier dans la mémoire

        Connectez BufferedReader au flux de données standard
        

        InputStreamReader sin=new InputStreamReader (System.in
        BufferedReader bin=new); BufferedReader(sin);
        public

        class ReadWriteToFile {

        
        public statique void main(String args[])

        lance une IOException {

        
        InputStreamReader sin =

        new InputStreamReader(System.in);

        1. BufferedReader bin =

           new BufferedReader(sin >
        FileWriter out); =
        2. nouveau FileWriter(

           "myfile.txt");
           

        3. BufferedWriter bout = nouveau Buffer edWriter( out); >

        Chaîne s;

        4. while ((s = bin.readLine()).length( ) > 0) {

        >

        5. }  

           } 

        7. } 

        8. Description du programme :
           Lire les caractères du clavier et les écrire dans le fichier. Méthode de la classe BufferedReader : String readLine()
           Fonction : Lire une ligne de chaîne se terminant par un caractère de retour chariot.
           Méthodes de la classe BufferedWriter : bout.write(String s,offset,len)
           Fonction : Démarrez la chaîne s à partir du décalage du tampon et écrivez une chaîne de longueur len dans un certain à.
           
           

           
           

           
           

           8. Flux de caractères Writer/Reader

           Les caractères en Java adoptent la norme Unicode. Un caractère fait 16 bits, c'est-à-dire qu'un caractère est représenté par deux octets. À cette fin, des flux de traitement des caractères ont été introduits en JAVA.

           1. Classe abstraite de lecteur

           Une classe abstraite pour lire les flux de caractères. Les seules méthodes que les sous-classes doivent implémenter sont read(char[], int, int) et close(). Cependant, la plupart des sous-classes remplaceront certaines des méthodes définies ici pour offrir une plus grande efficacité et/ou des fonctionnalités supplémentaires.

                                                                                                                                 : (1) Prenez le nom du fichier sous forme de chaîne : FileReader f=new FileReader("c:/temp.txt");

           (2) Le constructeur prend l'objet File comme son paramètre.

           File f=new file("c:/temp.txt"); FileReader f1=new FileReader(f); (3) Le constructeur prend l'objet FileDescriptor comme paramètre Descriptor() fd=new FileDescriptor () 　    FileReader f2=new FileReader(fd); 2) sera un tableau de caractères comme flux d'entrée : CharArrayReader(char[], int, int)
           Lire une chaîne, le constructeur est le suivant : public StringReader( String s);
           
           2) CharArrayReader :
           et ByteArrayInputStream correspondant à
           　
           3) StringReader :
           Correspond à StringBufferInputStream
           　
           4) InputStreamReader 　 Lire les octets du flux d'entrée et les convertir en caractères : Public inputstreamReader( inputstream is);
           　
           5) FilterReader :
           Autorise le filtrage du flux de caractères 　 protected filterReader(Reader r); 🎜>　6) BufferReader :
           accepte l'objet Reader comme paramètre, ajoutez-y un tampon de caractères et utilisez la méthode readline() pour lire une ligne. Public BufferReader(Reader r);
           Méthode principale :
           (1) public int read() lance IOException //Lire un caractère, la valeur de retour est lue Le caractère pris
           　(2) public int read(char cbuf[]) throws IOException; /* Lit une série de caractères dans le tableau cbuf[], et la valeur de retour est le caractère lu réel Quantité*/
           (3) public abstract int read(char cbuf[],int off,int len) throws IOException
           /* Lire les caractères len, à partir de l'indice du tableau cbuf[] Storage, la valeur de retour est le nombre réel de caractères lus, cette méthode doit être implémentée par une sous-classe*/ 2 Classe abstraite Writer
           

           Classe abstraite pour l'écriture de flux de caractères. Les seules méthodes que les sous-classes doivent implémenter sont write(char[], int, int), flush() et close(). Cependant, la plupart des sous-classes remplaceront certaines des méthodes définies ici pour offrir une plus grande efficacité et/ou des fonctionnalités supplémentaires. Ses sous-catégories sont les suivantes :

           1) FileWrite : correspond à FileOutputStream
           Écrivez des données de type caractère dans le fichier, en utilisant l'encodage de caractères et la taille du tampon par défaut.
           　Public FileWrite(file f);
           　2) chararrayWrite : Correspond à ByteArrayOutputStream, en utilisant le tampon de caractères comme sortie.
           　 Public CharArrayWrite();
           　3) PrintWrite : générer sortie formatée
           　 public PrintWriter(outputstream os
           　4) filterWriter : utilisé pour écrire le flux de caractères de filtre
           protected FilterWriter(Writer w);
           　5) PipedWriter : Correspond à PipedOutputStream

           6) StringWriter : Il n'y a pas de flux orienté octet correspondant

           Méthode principale :

           (1) public void write(int c) throws IOException; //Écrit les 16 bits inférieurs de la valeur entière c dans le flux de sortie
           　(2) public void write(char cbuf[]) throws IOException; le tableau de caractères cbuf[] dans le flux de sortie
           　(3) public abstract void write(char cbuf[],int off,int len) lance IOException ; //Écrit les caractères du tableau de caractères cbuf[] dans la sortie. stream Index est écrit dans le flux de sortie à partir des caractères len à la position off
           　(4) public void write(String str) throws IOException //Écrit les caractères de la chaîne str dans le flux de sortie
           　(5) public void write(String str,int off,int len) lance IOException ; //Écrit les caractères len à partir de l'index off dans la chaîne str vers le flux de sortie
           (6) flush( ) / /Flush le flux de sortie et affiche tous les octets mis en mémoire tampon.
           　(7)close() Fermez le flux public abstract void close() lance IOException

           Différence entre InputStream et Reader Différence entre OutputStream et Writer

           Les classes InputStream et OutputStream traitent les flux d'octets, et la plus petite unité du flux de données est l'octet (8 bits)
           Reader et Writer traitent les caractères Stream , lors du traitement des flux de caractères, le problème de la conversion du codage des caractères est impliqué

           
           

           1. import java.io.* ;

           2. public class EncodeTest {

           3. >statique void readBuff(byte [] buff) lance IOException {

           ByteArrayInputStream in =
           4. new ByteArrayInputStream(buff);

           while((data=in.read())!=-
           5. 1) System.out.print(data+

              " ");

           6. System.out.println(); in.close(); }

           7. public
           statique
           8. void main(String args[])

              lance IOException {
              

           9. System.out.println ("Le codage des caractères Unicode est utilisé en mémoire :" 🎜>

           10.  

               int lowBit=c&0xFF;  int highBit=(c&

               0xFF00)>>
           8; 
           12. System.out.println(

               ""+lowBit+" "+highBit

           13. String s="Bon";

           14. System.out.println("Encodage des caractères par défaut du système d'exploitation local : ");

           15. readBuff(s.getBytes());

           16. System.out.println(" Utilisation de l'encodage de caractères GBK : ");

           17. readBuff(s.getBytes("GBK"));

           18. System.out.println("Encodage des caractères UTF-8 :");

           19. readBuff(s.getBytes("UTF- 8 ")); } 

           20. } 

           
           

           
           Lecteur Le La classe peut convertir les caractères d'autres types de codage dans le flux d'entrée en caractères Unicode, puis leur allouer de la mémoire dans la mémoire
           La classe Writer peut convertir les caractères Unicode de la mémoire en caractères dans d'autres types de codage, puis écrire au milieu du flux de sortie.
           
           

           
           

           
           

           9. Sous-classes de la classe d'exception IOException

           1.public class EOFException :
           Ce type d'exception est levé lorsque la fin du fichier ou la fin du flux d'entrée est atteinte anormalement.
           2.public class FileNotFoundException :
           Exception levée lorsque le fichier est introuvable.
           3.public class InterruptedIOException :

           Ce type d'exception est levé lorsque l'opération d'E/S est interrompue.

    Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!