1.Qu'est-ce que l'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 Java sont basés sur des flux de données pour l'entrée et la sortie. Ces flux de données représentent la séquence fluide de caractères ou d'octets de données. Les flux d'E/S Java fournissent des méthodes standard pour lire et écrire des données. Tout objet Java qui représente une source de données 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.
Modèle d'E/S Java :
La conception du modèle IO de Java est très excellente. Elle utilise le modèle Decorator pour diviser les flux par fonction. Vous pouvez assembler dynamiquement ces flux pour obtenir les fonctions dont vous avez besoin. 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.
2. 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 ce que l'on voit à l'autre extrémité de la conduite d'eau est un flux continu. d'eau. 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 la destination des données stockées sur un disque ou un autre périphérique."
Il existe trois façons de stocker des données sur un ordinateur : l’une est le stockage externe, l’autre la mémoire et l’autre 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, la partie IO est très volumineuse car elle couvre un large éventail de domaines :
Entrées et sorties standard, opérations sur les fichiers, flux de données sur le réseau, flux de chaînes, flux d'objets, flux de fichiers zip, etc. En Java, l'abstraction des entrées et des sorties est appelée un flux, qui est comme une conduite d'eau reliant deux conteneurs. 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.
Le flux 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 :
Une séquence ordonnée d'octets avec un point de départ et un point de fin. Y compris le flux d’entrée et le flux de sortie.
2) 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.
Le but de l'utilisation de flux de données est de rendre la sortie et l'entrée indépendantes de l'appareil.
Input Stream ne se soucie pas du périphérique d'où provient la source de données (clavier, fichier, réseau)
Le flux de sortie ne se soucie pas du périphérique auquel les données sont destinées (clavier, fichier, réseau).
3.E/S standard
Les programmes Java peuvent échanger de brèves informations avec le monde extérieur via des paramètres de ligne de commande. En même temps, il stipule également comment échanger des informations avec des périphériques d'entrée et de sortie standard, tels que des claviers et des 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 commandeRésultats en cours d'exécution :
args[0] est <Java>
args[1] est <C>
args[2] est <VB>
Le flux de données standard fourni avec le système Java : java.lang.System :
Avis:
(1) La classe System ne peut pas créer d'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 envoie les données vers le périphérique de sortie standard et son type de données est PrintStream. méthode:
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:
3) Flux d'erreurs standard
System.err génère une erreur standard et 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 encapsuler de nouvelles lignes, tandis que la méthode d'impression génère des paramètres mais n'encapsule pas de nouvelles lignes. 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.
classe publique StandardInputOutput {
public static void main(String args[]) {
Chaîne s ;
//Créer un lecteur de tampon pour lire les données ligne par ligne à partir du clavier
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader dans = nouveau BufferedReader(ir);
System.out.println("Système Unix : ctrl-d ou ctrl-c pour quitter"
+ "/nSystème Windows : ctrl-z quitter");
essayer {
//Lire une ligne de données et l'afficher sur le moniteur en standard
s = in.readLine();
// Si une erreur d'E/S se produit lors de l'exécution de la méthode readLine(), une IOException sera levée.
tandis que (s != nul) {
System.out.println("Lire : " + s);
s = in.readLine();
}
// Ferme le lecteur tamponné
joindre();
} catch (IOException e) { // Intercepte toutes les exceptions IO.
e.printStackTrace();
}
}
}
4.java.IOArchitecture hiérarchique
Les éléments les plus importants de l’ensemble du package Java.io sont 5 classes et une interface. Les cinq classes font référence à File, OutputStream, InputStream, Writer et Reader ; une interface fait référence à Serialisable. Une fois que vous maîtriserez ces opérations d'E/S de base, vous aurez une compréhension préliminaire du système d'E/S en Java.
Java I/O comprend principalement les niveaux suivants, comprenant trois parties :
1. La partie principale de la partie streaming IO ;
2. La partie non-streaming comprend principalement certaines classes qui assistent la partie streaming, telles que : la classe File, la classe RandomAccessFile et la classe FileDescriptor ;
3. Autres classes : classes liées à la sécurité dans la partie lecture de fichiers, telles que la classe SerializingPermission, et classes de système de fichiers liées au système d'exploitation local, telles que la classe FileSystem, la classe Win32FileSystem et la classe WinNTFileSystem.
Les principales classes sont les suivantes :
1. Fichier (caractéristiques et gestion des fichiers) : utilisé pour les informations de description de fichiers ou de répertoires, telles que la génération de nouveaux répertoires, la modification des noms de fichiers, la suppression de fichiers, la détermination du chemin d'accès au fichier, etc.
2. InputStream (opération au format binaire) : classe abstraite, opération d'entrée basée sur les octets et 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 comporte 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 et peut 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 la suivante :
5. Classe de fichiers sans streaming - Classe de fichiers
}
Description : Méthodes de la classe File :
(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ée le fichier spécifié par l'objet fichier
(4) list() renvoie toutes les chaînes de noms de fichiers dans le répertoire
6. Bibliothèque de classes de flux Java.IO
Le package java.io contient toutes les classes nécessaires au streaming des E/S. Il existe quatre classes de base dans le package java.io : les classes InputStream, OutputStream, Reader et Writer, qui gèrent respectivement les flux d'octets et les flux de caractères :
E/S de flux de données de base
entrée/sortie
flux d'octets
flux de caractères
flux d'entrée
Flux d'entrée
Lecteur
flux de sortie
Flux de sortie
Écrivain
Diverses autres variantes de flux en Java en dérivent :
La version JDK1.4 a commencé à introduire une nouvelle bibliothèque de classes d'E/S, située dans le package java.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 io1. Classification globale par type d'E/S :
1. Mémoire 1) Lire et écrire des données depuis/vers la matrice mémoire : CharArrayReader, CharArrayWriter, ByteArrayInputStream, ByteArrayOutputStream
2) Lire et écrire des données depuis/vers les chaînes de mémoire StringReader, StringWriter, StringBufferInputStream
2.Pipe pipeline implémente l'entrée et la sortie du pipeline (communication inter-processus) : PipedReader, PipedWriter, PipedInputStream, PipedOutputStream
3.Fichier le flux de fichiers . Lire et écrire des fichiers : FileReader, FileWriter, FileInputStream, FileOutputStream
4. Entrée et sortie de l'objet ObjectSerialization : ObjectInputStream, ObjectOutputStream
5. Le flux de données DataConversion lit et écrit selon les types de données de base (les données traitées sont les types de base de Java (tels que les booléens, les octets, les entiers et les nombres à virgule flottante)) : DataInputStream, DataOutputStream
6. L'impression comprend des méthodes d'impression pratiques : PrintWriter, PrintStream
7. La mise en mémoire tampon met 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. Filtrage du flux de filtrage , filtrage lorsque les données sont lues ou écrites : FilterReader, FilterWriter, FilterInputStream, FilterOutputStream pass
9.La concaténation fusionne les entrées et connecte plusieurs flux d'entrée en un seul flux d'entrée : SequenceInputStream
10.Le comptage compte les lignes lors de la lecture des données : LineNumberReader, LineNumberInputStream
11.Peeking Ahead effectue une pré-lecture via le mécanisme de mise en cache : PushbackReader, PushbackInputStream
12.La conversion entre octets et caractères convertit le flux d'octets en flux de caractères selon certaines normes de codage/décodage, ou effectue une conversion inverse (Stream to Reader, classe de conversion Writer) : InputStreamReader, OutputStreamWriter
2. Classification par source de données (destination) :
1. Fichier : FileInputStream, FileOutputStream, FileReader, FileWriter
2. octet[] : ByteArrayInputStream, ByteArrayOutputStream
3. Char[] : CharArrayReader, CharArrayWriter
4. Chaîne : StringBufferInputStream, StringReader, StringWriter
5. Flux de données réseau : InputStream, OutputStream, Reader, Writer
7. Flux d'octets InputStream/OutputStream
InputStream est un flux d'entrée d'octets. C'est lui-même une classe abstraite et doit s'appuyer sur ses sous-classes pour implémenter diverses fonctions. Cette classe abstraite est la super classe de toutes les classes qui représentent des flux d'entrée d'octets. Flux hérités des données d'entrée InputStream dans le programme, et l'unité de données est en octets (8 bits) ;
InputStream est une classe utilisée pour saisir des données d'octets, donc la classe InputStream fournit trois méthodes de lecture surchargées dans la classe Inputstream :
(1) public abstract int read() : lit un octet de données et la valeur de retour est une valeur de type int avec les bits de poids fort 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 avec un décalage de off dans le tableau b.
(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, saute quelques octets à lire (6) public int close() : nous sommes après utilisation, le le flux que nous avons ouvert doit être fermé.
Principales sous-catégories :
1) FileInputStream utilise un fichier comme InputStream pour réaliser l'opération de lecture du fichier 2) ByteArrayInputStream : utilise un tampon dans la mémoire comme InputStream 3) StringBufferInputStream : utilise un objet String comme InputStream
4) PipedInputStream : implémente le concept de pipe, principalement utilisé dans les threads 5) SequenceInputStream : fusionne plusieurs InputStreams en un seul InputStream
Principales sous-catégories :
1) ByteArrayOutputStream : stocker les informations dans un tampon en mémoire
2) FileOutputStream : stocker les informations dans un fichier
3) PipedOutputStream : implémente le concept de pipe, principalement utilisé dans les threads
4) SequenceOutputStream : fusionner plusieurs OutStreams en un seul OutStream
Détermination de la fin du flux : lorsque la valeur de retour de la méthode read() est -1 ; lorsque la valeur de retour de readLine() est nulle.
3. Flux d'entrée de fichier : classe FileInputStreamFileInputStream peut utiliser la méthode read() pour lire un octet à la fois et le renvoyer sous forme de type int, ou utiliser la méthode read() pour lire dans un tableau d'octets. Combien d'octets sont lus en fonction du nombre d'éléments dans le tableau. 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.
Comment utiliser (2)
FileInputStream in=newFileInputStream("d: /abc.txt");
Exemple de programme :
Afficher le contenu du programme InputFromFile.java sur le moniteur
classe publique TestFile {
public static void main (String args []) lance IOException {
essayer{
FileInputStream rf=new FileInputStream("InputFromFile.java");
int n=512 ; tampon d'octets[]=nouvel octet[n] ;
while((rf.read(buffer,0,n)!=-1)&&(n>0)){
System.out.println(new String(buffer) );
}
System.out.println();
rf.close();
} catch(IOException IOe){
System.out.println(IOe.toString());
}
}
}
La classe FileOutputStream est utilisée pour traiter les flux de données qui utilisent des fichiers comme destinations de sortie de données ; une chaîne représentant le nom du fichier, qui peut également être un objet File ou FileDescriptor.
Il existe deux manières de créer un objet flux de fichiers :
Voie 1 :
Fichier f=nouveau fichier ("d:/myjava/write.txt ");
FileOutputStream out= nouveau FileOutputStream (f);
Voie 2 :
FileOutputStream out=new FileOutputStream("d:/myjava/write.txt ");
Méthode 3 : Le constructeur prend l'objet FileDescriptor() comme paramètre.
FileDescriptor() fd=new FileDescriptor();
FileOutputStream f2=nouveau FileOutputStream(fd);
Méthode 4 : Le constructeur prend le nom du fichier comme premier paramètre et une valeur booléenne comme deuxième paramètre.
FileOutputStream f=new FileOutputStream("d:/abc.txt",true);
Remarque : (1) Lors de l'écriture de données dans un fichier, si le fichier existe déjà, le fichier existant sera écrasé ; (2) Lorsque l'opération de lecture/écriture se termine, la méthode close doit être appelée pour fermer le flux ;
}
classe publique TestFile {
public static void main (String args []) lance IOException {
essayer {
Fichier inFile = new File("copy.java");
Fichier outFile = new File("copy2.java");
FileInputStream finS = new FileInputStream(inFile);
FileOutputStream foutS = new FileOutputStream(outFile);
int c;
while ((c = finS.read()) != -1) {
foutS.write(c);
}
finS.close();
foutS.close();
} catch (IOException e) {
System.err.println("FileStreamsTest: " + e);
}
}
}
L'accès de l'ordinateur aux périphériques externes prend du temps. 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 une fois le tampon plein, le système envoie immédiatement les données au périphérique de sortie.
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.
Connectez BufferedInputStream à FileInputStream
FileInputStream=newFileInputStream( "file1.txt " );
BufferedInputStreambin=newBufferedInputStream(in);
2) Écrivez la mémoire dans un fichier :
Connectez BufferedOutputStream à FileOutputStream
FileOutputStreamout=newFileOutputStream("file1.txt");
BufferedOutputStreambin=newBufferedInputStream(out);
classe publique ReadWriteToFile {
public static void main (String args []) lance IOException {
InputStreamReader sin = new InputStreamReader(System.in);
BufferedReader bin = nouveau BufferedReader(sin);
FileWriter out = new FileWriter("monfichier.txt");
BufferedWriter bout = new BufferedWriter(out);
Chaîne s ;
while ((s = bin.readLine()).length() > 0) {
bout.write(s, 0, s.length());
}
}
}
8. Écrivain/lecteur de flux de caractères
Les caractères en Java adoptent la norme Unicode. Un caractère comporte 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.
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) FileReader : Correspondant à FileInputStream, il est principalement utilisé pour lire des fichiers de caractères, en utilisant l'encodage de caractères par défaut, et possède trois constructeurs :
(1) Utilisez le nom du fichier comme chaîne : FileReader f=new FileReader("c:/temp.txt");
(2) Le constructeur prend l'objet File comme paramètre.
Fichier f=nouveau fichier("c:/temp.txt");
FileReader f1=nouveau FileReader(f);
(3) Le constructeur prend l'objet FileDescriptor comme paramètre
FileDescriptor() fd=nouveau FileDescriptor()
FileReader f2=nouveau FileReader(fd);
(1) Utilisez le tableau de caractères spécifié comme paramètre : CharArrayReader(char[])
(2) Utiliser un tableau de caractères comme flux d'entrée : CharArrayReader(char[], int, int)
Pour lire une chaîne, le constructeur est le suivant : public StringReader(String s);
2) CharArrayReader : correspond à ByteArrayInputStream
3) StringReader : correspond à StringBufferInputStream
4) Lecteur de flux d'entrée
Lire les octets du flux d'entrée et les convertir en caractères : Public inputstreamReader(inputstream is );
5) FilterReader : permet de filtrer les flux de caractères
filterReader protégé (Lecteur r);
6) BufferReader : accepte un objet Reader comme paramètre et y ajoute un tampon de caractères. Utilisez la méthode readline() pour lire une ligne.
Public BufferReader (Lecteur r);
Principales méthodes :
(1) publicintread()throwsIOException;//Lire un caractère, la valeur de retour est le caractère lu
(2) publicintread(charcbuf[])throwsIOException;/*Lire une série de caractères dans le tableau cbuf[], et la valeur de retour est le nombre de caractères réellement lus*/
(3) publicabstractintread(charcbuf[],intoff,intlen)throwsIOException ;
/*Lire les caractères len et les stocker à partir de l'indice du tableau cbuf[]. 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*/.
Classe abstraite pour écrire dans des 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 et écrit les données de type caractère dans un fichier, en utilisant le codage de caractères et la taille du tampon par défaut.
FileWrite public (fichier f);
2) chararrayWrite : correspond à ByteArrayOutputStream, en utilisant le tampon de caractères comme sortie.
Public CharArrayWrite();
3) PrintWrite : générer une sortie formatée public PrintWriter (outputstream os);
4) filterWriter : utilisé pour écrire un flux de caractères de filtre protégé FilterWriter(Writer w);
5) PipedWriter : correspond à PipedOutputStream
6) StringWriter : il n'y a pas de flux orienté octet correspondant
Principales méthodes :
(1) publicvoidwrite(intc)throwsIOException; //Écrit les 16 bits inférieurs de la valeur entière c dans le flux de sortie (2) publicvoidwrite(charcbuf[])throwsIOException; //Écrit le tableau de caractères cbuf[] dans le flux de sortie ( 3) publicabstractvoidwrite(charcbuf[],intoff,intlen) throwsIOException; //Écrit les caractères len à partir de l'index off dans le tableau de caractères cbuf[] dans le flux de sortie (4) publicvoidwrite(Stringstr)throwsIOException; //Écrivez les caractères dans la chaîne. str sont écrits dans le flux de sortie (5) publicvoidwrite(Stringstr,intoff,intlen)throwsIOException; // Écrit les caractères len à partir de l'index off dans la chaîne str dans le flux de sortie (6) flush() // Vide le flux de sortie et affiche tous les mots mis en cache Festival.
(7)close() ferme le flux publicabstractvoidclose()throwsIOException
3. La différence entre InputStream et Reader, la différence entre OutputStream et Writer
public static void main (String args []) lance IOException {
System.out.println("Le codage des caractères Unicode est utilisé en mémoire : ");
char c='bon';
int lowBit=c&0xFF; int highBit=(c&0xFF00)>>8;
System.out.println(""+lowBit+" "+highBit);
Chaîne s="OK" ;
System.out.println("Encodage des caractères par défaut du système d'exploitation local :");
readBuff(s.getBytes());
System.out.println("Utilisation du codage de caractères GBK :");
readBuff(s.getBytes("GBK"));
System.out.println("Encodage des caractères UTF-8 :");
readBuff(s.getBytes("UTF-8")); }
}
9. Sous-classes de la classe d'exception IOException
1.classe publique EOFException :
Ce type d'exception est levée lorsque la fin du fichier ou la fin du flux d'entrée est atteinte anormalement.
2.classe publique FileNotFoundException :
Exception levée lorsque le fichier est introuvable.
3.classe publique InterruptedIOException :
Ce type d'exception est lancé lorsqu'une opération d'E / S est interrompue.