Penser en Java - 11) Le système d’E/S de Java

11) Le système d’E/S de Java

Texte original

Traducteur : Armel Fortun

///

Ce chapitre contient 10 pages
1 2 3 4 5 6 7 8 9 10

\\\

Table 11-1. Types of InputStream

Tableau 11-1. Types d'InputStream

Class	Function	Constructor Arguments
Class	Function	How to use it
ByteArray-InputStream	Allows a buffer in memory to be used as an InputStream	The buffer from which to extract the bytes.
ByteArray-InputStream	Allows a buffer in memory to be used as an InputStream	As a source of data. Connect it to a FilterInputStream object to provide a useful interface.
StringBuffer-InputStream	Converts a String into an InputStream	A String. The underlying implementation actually uses a StringBuffer.
StringBuffer-InputStream	Converts a String into an InputStream	As a source of data. Connect it to a FilterInputStream object to provide a useful interface.
File-InputStream	For reading information from a file	A String representing the file name, or a File or FileDescriptor object.
File-InputStream	For reading information from a file	As a source of data. Connect it to a FilterInputStream object to provide a useful interface.
Piped-InputStream	Produces the data that’s being written to the associated PipedOutput-Stream. Implements the “piping” concept.	PipedOutputStream
Piped-InputStream		As a source of data in multithreading. Connect it to a FilterInputStream object to provide a useful interface.
Sequence-InputStream	Converts two or more InputStream objects into a single InputStream.	Two InputStream objects or an Enumeration for a container of InputStream objects.
Sequence-InputStream		As a source of data. Connect it to a FilterInputStream object to provide a useful interface.
Filter-InputStream	Abstract class which is an interface for decorators that provide useful functionality to the other InputStream classes. See Table 11-3.	See Table 11-3.
Filter-InputStream		See Table 11-3.

Classe	Fonction	Arguments du Constructeur
Classe	Fonction	Mode d'emploi
ByteArray-InputStream	Autorise un tampon en mémoire pour être utilisé comme InputStream	Le tampon depuis lequel extraire les bytes.
ByteArray-InputStream		Comme une source de données. Connectez le a un objet FilterInputStream pour fournir une interface pratique.
StringBuffer-InputStream	Convertit un String en un InputStream	Un String. L'implémentation fondamentale utilise actuellement un StringBuffer.
StringBuffer-InputStream	Convertit un String en un InputStream	Comme une source de données. Connectez le a un objet FilterInputStream pour fournir une interface pratique.
File-InputStream	Pour lire les information depuis un fichier.	Un String représentant le nom du fichier, ou un objet File ou FileDescriptor.
File-InputStream	Pour lire les information depuis un fichier.	Comme une source de données. Connectez le a un objet FilterInputStream pour fournir une interface pratique.
Piped-InputStream	Produit la donnée qui sera écrite vers le PipedOutput-Stream associé. Applique le concept de « tuyauterie ».	PipedOutputStream
Piped-InputStream		Comme une source de données. Connectez le a un objet FilterInputStream pour fournir une interface pratique.
Sequence-InputStream	Convertit deux ou plusieurs objets InputStream dans seul InputStream.	Deux objets InputStream ou une Énumeration pour un récipient d'objets InputStream.
Sequence-InputStream		Comme une source de données. Connectez le a un objet FilterInputStream pour fournir une interface pratique.
Filter-InputStream	Classe abstraite qui est une interface pour les décorateurs lesquels fournissent une fonctionnalité profitable aux autres classe InputStream. Voir Tableau 11-3.	Voir Tableau 11-3.
Filter-InputStream		Voir Tableau 11-3.

Types of OutputStream

Les types d'OutputStream

This category includes the classes that decide where your output will go: an array of bytes (no String, however; presumably you can create one using the array of bytes), a file, or a “pipe.”

Cette catégorie contient les classes qui décident de l'endroit où iront vos données de sorties : un tableau de bytes (pas de String, cependant ; vraisemblablement vous pouvez en créer un en utilisant le tableau de bytes), un fichier, ou un « tuyau.»

In addition, the FilterOutputStream provides a base class for "decorator" classes that attach attributes or useful interfaces to output streams. This is discussed later.

En complément, le FilterOutputStream fournit une classe de base pour les classes de « décoration » qui attachent des attributs ou des interfaces utiles aux flux de sortie.

Table 11-2. Types of OutputStream

Tableau 11-2. Les types d'OutputStream

Class	Function	Constructor Arguments
Class	Function	How to use it
ByteArray-OutputStream	Creates a buffer in memory. All the data that you send to the stream is placed in this buffer.	Optional initial size of the buffer.
ByteArray-OutputStream		To designate the destination of your data. Connect it to a FilterOutputStream object to provide a useful interface.
File-OutputStream	For sending information to a file.	A String representing the file name, or a File or FileDescriptor object.
File-OutputStream	For sending information to a file.	To designate the destination of your data. Connect it to a FilterOutputStream object to provide a useful interface.
Piped-OutputStream	Any information you write to this automatically ends up as input for the associated PipedInput-Stream. Implements the “piping” concept.	PipedInputStream
Piped-OutputStream		To designate the destination of your data for multithreading. Connect it to a FilterOutputStream object to provide a useful interface.
Filter-OutputStream	Abstract class which is an interface for decorators that provide useful functionality to the other OutputStream classes. See Table 11-4.	See Table 11-4.
Filter-OutputStream		See Table 11-4.

Classe	Fonction	Arguments du constructeur
Classe	Fonction	Mode d'emploi
ByteArray-OutputStream	Crée un tampon en mémoire. Toutes les données que vous envoyez vers le flux sont placées dans ce tampon.	En option la taille initiale du tampon.
ByteArray-OutputStream		Pour désigner la destination de vos données. Connectez le à un objet FilterOutpuStream pour fournir une interface pratique.
File-OutputStream	Pour envoyer les informations a un fichier.	Un String représentant le nom d'un fichier, ou un objet File ou FileDescriptor.
File-OutputStream	Pour envoyer les informations a un fichier.	Pour désigner la destination de vos données. Connectez le à un objet FilterOutpuStream pour fournir une interface pratique.
Piped-OutputStream	N'importe quelle information que vous écrivez vers celui-ci se termine automatiquement comme une entrée du PipedInput-Stream associé. Applique le concept de « tuyauterie. »	PipedInputStream
Piped-OutputStream		Pour indiquer la destination de vos données pour une exécution multiple [multithreading]. Connectez le à un objet FilterOutpuStream pour fournir une interface pratique.
Filter-OutputStream	Classe abstraite qui est une interface pour les décorateurs qui fournissent des fonctionnalités pratiques aux autres classes d'OutputStream. Voir Tableau 11-4.	Voir Tableau 11-4.
Filter-OutputStream		Voir Tableau 11-4.

Adding attributes
and useful interfaces

Ajouter des attributs et des interfaces utiles

The use of layered objects to dynamically and transparently add responsibilities to individual objects is referred to as the Decorator pattern. (Patterns[57] are the subject of Thinking in Patterns with Java, downloadable at www.BruceEckel.com.) The decorator pattern specifies that all objects that wrap around your initial object have the same interface. This makes the basic use of the decorators transparent—you send the same message to an object whether it’s been decorated or not. This is the reason for the existence of the “filter” classes in the Java I/O library: the abstract “filter” class is the base class for all the decorators. (A decorator must have the same interface as the object it decorates, but the decorator can also extend the interface, which occurs in several of the “filter” classes).

L'emploi d'objets en couches pour ajouter dynamiquement et de manière claire des responsabilités aux objets individuels est mentionné comme un Pattern de Décoration. (Les Patterns[ 57 ] sont le sujet de Thinking in Patterns with Java, téléchargeable à <www.BruceEckel.com>.) Le Pattern de décoration précise que tous les objets qui entourent votre objet initial possèdent la même interface. Ceci rend l'usage basique des décorateurs claire — vous envoyez le même message à un objet qu'il soit décoré ou non. C'est la raison de l'existence des classes « filter » dans la bibliothèque E/S de Java : la classe abstraite « filter » est la classe de base pour tous les décorateurs. (Un décorateur doit avoir la même interface que l'objet qu'il décore, mais le décorateur peut aussi étendre l'interface, ce qui se produit dans un certain nombre de classes « filter »).

Decorators are often used when simple subclassing results in a large number of subclasses in order to satisfy every possible combination that is needed—so many subclasses that it becomes impractical. The Java I/O library requires many different combinations of features, which is why the decorator pattern is used. There is a drawback to the decorator pattern, however. Decorators give you much more flexibility while you’re writing a program (since you can easily mix and match attributes), but they add complexity to your code. The reason that the Java I/O library is awkward to use is that you must create many classes—the “core” I/O type plus all the decorators—in order to get the single I/O object that you want.

Les décorateurs sont souvent employés quand un simple sous-classement touche un grand nombre de sous-classes pour satisfaire toutes les combinaisons possibles nécessaires — avec tellement de sous-classes que cela devient peu pratique. La bibliothèque d'E/S Java demande différentes combinaisons de caractéristiques, c'est pourquoi le Pattern de décoration est employé. Il y a un désavantage au Pattern de décoration, néanmoins les décorateurs vous donnent une plus grande flexibilité pendant l'écriture d'un programme (puisque vous pouvez facilement mélanger et assembler des attributs [attributes]), mais ils ajoutent de la complexité à votre code. La raison pour laquelle la bibliothèque d'E/S de Java n'est pas pratique d'emploi est que vous devez créer beaucoup de classes — le type « noyau » d'E/S plus tous les décorateurs — afin d'obtenir le simple objet E/S désiré.

The classes that provide the decorator interface to control a particular InputStream or OutputStream are the FilterInputStream and FilterOutputStream—which don’t have very intuitive names. FilterInputStream and FilterOutputStream are abstract classes that are derived from the base classes of the I/O library, InputStream and OutputStream, which is the key requirement of the decorator (so that it provides the common interface to all the objects that are being decorated).

Les classes qui procurent l'interface de décoration pour contrôler un InputStream ou OutputStream particulier sont FilterInputStream et FilterOutputStream — lesquelles n'ont pas des noms très intuitifs. FilterInputStream et FilterOutputStream sont des classes abstraites qui sont dérivées depuis les classes de base de la bibliothèque d'E/S, InputStream et OutputStream, ceci étant l'exigence clef du décorateur (afin qu'il procure une interface commune à tous les objets qui seront décorés).

Reading from an InputStream
with FilterInputStream

Lire depuis un InputStream avec FilterInputStream

The FilterInputStream classes accomplish two significantly different things. DataInputStream allows you to read different types of primitive data as well as String objects. (All the methods start with “read,” such as readByte( ), readFloat( ), etc.) This, along with its companion DataOutputStream, allows you to move primitive data from one place to another via a stream. These “places” are determined by the classes in Table 11-1.

La classe FilterInputStream accomplit deux choses significatives différentes. DataInputStream vous permet de lire différents types de données primitives tout aussi bien que des objets String. (Toutes les méthodes commencent avec « read, » comme readByte(), readFloat(), etc.) Ceci, accompagné par DataOutputStream, vous permet de déplacer des données primitives d'une place à une autre en passant par un flux. Ces « places » sont déterminées par les classes du Tableau 11-1.

The remaining classes modify the way an InputStream behaves internally: whether it’s buffered or unbuffered, if it keeps track of the lines it’s reading (allowing you to ask for line numbers or set the line number), and whether you can push back a single character. The last two classes look a lot like support for building a compiler (that is, they were added to support the construction of the Java compiler), so you probably won’t use them in general programming.

Les classes restantes modifient le comportement interne d'un InputStream : s'il est mis en tampon ou pas, si il garde trace des lignes qu'il lit (vous permettant de demander des numéros de ligne ou de régler le numéro de ligne), et si vous pouvez pousser en arrière un caractère seul. Les deux dernières classes ressemblent beaucoup à une ressource pour construire un compilateur (c'est à dire, elles ont étés ajoutées en support pour la construction du compilateur Java), donc vous ne l'utiliserez probablement pas en programmation habituelle.

You’ll probably need to buffer your input almost every time, regardless of the I/O device you’re connecting to, so it would have made more sense for the I/O library to make a special case (or simply a method call) for unbuffered input rather than buffered input.

Vous devrez probablement presque tout le temps mettre en tampon votre entrée, sans prendre en compte l'élément d'E/S auquel vous vous connectez, ainsi il aurait été plus censé pour la bibliothèque d'E/S de faire un cas spécial (ou un simple appel de méthode)pour l'entrée non mise en tampon plutôt que pour l'entrée mise en tampon.

Table 11-3. Types of FilterInputStream

Tableau 11-3. Les types de FilterInputStream

Class	Function	Constructor Arguments
		How to use it
Data-InputStream	Used in concert with DataOutputStream, so you can read primitives (int, char, long, etc.) from a stream in a portable fashion.	InputStream
		Contains a full interface to allow you to read primitive types.
Buffered-InputStream	Use this to prevent a physical read every time you want more data. You’re saying “Use a buffer.”	InputStream, with optional buffer size.
		This doesn’t provide an interface per se, just a requirement that a buffer be used. Attach an interface object.
LineNumber-InputStream	Keeps track of line numbers in the input stream; you can call getLineNumber( ) and setLineNumber( int).	InputStream
		This just adds line numbering, so you’ll probably attach an interface object.
Pushback-InputStream	Has a one byte push-back buffer so that you can push back the last character read.	InputStream
		Generally used in the scanner for a compiler and probably included because the Java compiler needed it. You probably won’t use this.

Classe	Fonction	Arguments du constructeur
		Mode d'emploi
Data-InputStream	Employé de concert avec DataOutputStream, afin de lire des primitives (int, char, long, etc.) depuis un flux de manière portable.	InputStream
		Contient une interface complète vous permettant de lire les types de primitives.
Buffered-InputStream	Utilisez ceci pour empêcher une lecture physique chaque fois que vous désirez plus de données. Cela dit « Utiliser un tampon. »	InputStream, avec en option la taille du tampon.
		Ceci ne fournit pas une interface en soi, mais une condition permettant d'employer le tampon.
LineNumber-InputStream	Garde trace des numéros de ligne dans le flux d'entrée; vous pouvez appeler getLineNumber() et setLineNumber(int).	InputStream
		Cela n'ajoute que la numérotation des lignes, de cette façon on attachera certainement un objet interface.
Pushback-InputStream	Possède un tampon retour-chariot d'un byte permettant de pousser le dernier caractère lu en arrière.	InputStream
		Généralement employé dans le scanner pour un compilateur et probablement inclus parce qu'il était nécessaire au compilateur Java. Vous ne l'utiliserez probablement pas.

Writing to an OutputStream
with FilterOutputStream

Écrire vers un OutputStream avec FilterOutputStream

The complement to DataInputStream is DataOutputStream, which formats each of the primitive types and String objects onto a stream in such a way that any DataInputStream, on any machine, can read them. All the methods start with “write,” such as writeByte( ), writeFloat( ), etc.

Le complément à DataInputStream est DataOutputStream, lequel formate chacun des types de primitive et objets String vers un flux de telle sorte que n'importe quel DataInputStream, sur n'importe quelle machine, puisse le lire. Toutes les méthodes commencent par « write », comme writeByte(), writeFloat(), etc.

The original intent of PrintStream was to print all of the primitive data types and String objects in a viewable format. This is different from DataOutputStream, whose goal is to put data elements on a stream in a way that DataInputStream can portably reconstruct them.

À l'origine, l'objectif de PrintStream est d'imprimer tous les types de données primitive et objets String dans un format perceptible. Ce qui est différent de DataOutputStream, dont le but est de placer les éléments de données dans un flux de manière que DataInputStream puisse de façon portable les reconstruire.

The two important methods in PrintStream are print( ) and println( ), which are overloaded to print all the various types. The difference between print( ) and println( ) is that the latter adds a newline when it’s done.

Les deux méthodes importantes dans un PrintStream sont print() et println(), qui sont surchargées [overloaded] pour imprimer tous les types différents. La différence entre print() et println() est que le dernier ajoute une nouvelle ligne une fois exécuté.

PrintStream can be problematic because it traps all IOExceptions (You must explicitly test the error status with checkError( ), which returns true if an error has occurred). Also, PrintStream doesn’t internationalize properly and doesn’t handle line breaks in a platform independent way (these problems are solved with PrintWriter).

PrintStream peut être problématique car il piège toutes les IOExceptions (vous devrez tester explicitement le statut de l'erreur avec checkError(), lequel retourne true si une erreur c'est produite. Aussi, PrintStream n'effectue pas l'internationalisation proprement et ne traite pas les sauts de ligne de manière indépendante de la plate-forme (ces problèmes sont résolus avec PrintWriter).

BufferedOutputStream is a modifier and tells the stream to use buffering so you don’t get a physical write every time you write to the stream. You’ll probably always want to use this with files, and possibly console I/O.

BufferedOutputStream est un modificateur, il dit au flux d'employer le tampon afin de ne pas avoir une écriture physique chaque fois que l'on écrit vers le flux. On employera probablement souvent ceci avec les fichiers, et peut être la console E/S.

Table 11-4. Types of FilterOutputStream

Tableau 11-4. Les types de FilterOutputStream

Class	Function	Constructor Arguments
Class	Function	How to use it
Data-OutputStream	Used in concert with DataInputStream so you can write primitives (int, char, long, etc.) to a stream in a portable fashion.	OutputStream
Data-OutputStream		Contains full interface to allow you to write primitive types.
PrintStream	For producing formatted output. While DataOutputStream handles the storage of data, PrintStream handles display.	OutputStream, with optional boolean indicating that the buffer is flushed with every newline.
PrintStream		Should be the “final” wrapping for your OutputStream object. You’ll probably use this a lot.
Buffered-OutputStream	Use this to prevent a physical write every time you send a piece of data. You’re saying “Use a buffer.” You can call flush( ) to flush the buffer.	OutputStream, with optional buffer size.
Buffered-OutputStream		This doesn’t provide an interface per se, just a requirement that a buffer is used. Attach an interface object.

Classe	Fonction	Arguments du Constructeur
Classe	Fonction	Mode d'emploi
Data-OutputStream	Utilisé en concert avec DataInputStream afin d'écrire des primitives (int, char, long, etc.) vers un flux de manière portable.	OutputStream
Data-OutputStream		Contient une interface complète vous permettant d'écrire les types de primitives.
PrintStream	Pour produire une sortie formatée. Pendant que DataOutputStream manie le stockage de données, le PrintStream manie l'affichage.	OutputStream, avec une option boolean indiquant que le tampon est vidé avec chaque nouvelle ligne.
PrintStream		Doit être l'emballage « final » pour votre objet OutputStream. Vous l'utiliserez probablement beaucoup.
Buffered-OutputStream	Utilisez ceci en prévention d'une écriture physique à chaque fois que vous envoyez un morceau de donnée. En disant « Utilise un tampon. » Vous pouvez appeler flush() pour vider le tampon.	OutputStream, avec en option la taille du tampon.
Buffered-OutputStream		Ceci ne fournit pas une interface en soi, juste la nécessité de l'emploi du tampon soit utilisé. Attache un objet interface.

Readers & Writers

Lecteurs & écrivains [ *Loader**s & Writers* ]

Java 1.1 made some significant modifications to the fundamental I/O stream library (Java 2, however, did not make fundamental modifications). When you see the Reader and Writer classes your first thought (like mine) might be that these were meant to replace the InputStream and OutputStream classes. But that’s not the case. Although some aspects of the original streams library are deprecated (if you use them you will receive a warning from the compiler), the InputStream and OutputStream classes still provide valuable functionality in the form of byte-oriented I/O, while the Reader and Writer classes provide Unicode-compliant, character-based I/O. In addition:

Java 1.1 apporte quelques modifications significatives à la bibliothèque fondamentale de flux d'E/S (Java 2, cependant, n'apporte pas de modifications fondamentales). Quand vous voyez les classes Reader et Writer votre première pensée (comme la mienne) doit être que celles-ci ont pour intention de remplacer les classes InputStream et OutputStream. Mais ce n'est pas le cas. Quoique certains aspects de la bibliothèque originale de flux sont dépréciés (si vous les employez vous recevrez un avertissement de la part du compilateur), les classes InputStream et OutputStream fournissent pourtant de précieuses fonctions dans le sens d'un E/S orienté byte, tandis que les classes Reader et Writer fournissent une E/S à base de caractères se pliant à l'Unicode. En plus :

Java 1.1 added new classes into the InputStream and OutputStream hierarchy, so it’s obvious those classes weren’t being replaced.
There are times when you must use classes from the “byte” hierarchy in combination with classes in the “character” hierarchy. To accomplish this there are “bridge” classes: InputStreamReader converts an InputStream to a Reader and OutputStreamWriter converts an OutputStream to a Writer.

Java 1.1 a ajouté de nouvelles classes dans la hiérarchie d'InputStream et OutputStream, donc il est évident qu'elles ne sont pas remplacées.
Il y a des fois ou vous devrez employer les classes de la hiérarchie « byte » en combinaison avec les classes de la hiérarchie « caractère ». Pour cela il y à des classes « passerelles » : InputStreamReader convertit un InputStream en un Reader et OutputStreamWriter convertit un OutputStream en un Writer.

The most important reason for the Reader and Writer hierarchies is for internationalization. The old I/O stream hierarchy supports only 8-bit byte streams and doesn’t handle the 16-bit Unicode characters well. Since Unicode is used for internationalization (and Java’s native char is 16-bit Unicode), the Reader and Writer hierarchies were added to support Unicode in all I/O operations. In addition, the new libraries are designed for faster operations than the old.

La raison la plus importante des hiérarchies de Reader et Writer est l'internationalisation. L'ancienne hiérarchie de flux d'E/S ne supporte que des flux de bytes de 8-bit et ne traite pas bien les caractères Unicode de 16-bit. Depuis qu'Unicode est employé pour l'internationalisation (et les char natifs de Java sont en Unicode 16-bit), les hiérarchies de Reader et Writer ont été ajoutées pour supporter l'Unicode dans toutes les opérations d'E/S. En plus, les nouvelles bibliothèques sont conçues pour des opérations plus rapides que l'ancienne.

As is the practice in this book, I will attempt to provide an overview of the classes, but assume that you will use online documentation to determine all the details, such as the exhaustive list of methods.

Comme il est de coutume dans ce livre, j'aurais aimé fournir une synthèse des classes, mais j'ai supposé que vous utiliserez la documentation en ligne pour éclaircir les détails, comme pour la liste exhaustive des méthodes.

Sources and sinks of data

Les sources et les réceptacles de données

Almost all of the original Java I/O stream classes have corresponding Reader and Writer classes to provide native Unicode manipulation. However, there are some places where the byte-oriented InputStreams and OutputStreams are the correct solution; in particular, the java.util.zip libraries are byte-oriented rather than char-oriented. So the most sensible approach to take is to try to use the Reader and Writer classes whenever you can, and you’ll discover the situations when you have to use the byte-oriented libraries because your code won’t compile.

Presque toutes les classes originales de flux d'E/S Java possèdent des classes Reader et Writer correspondantes afin de fournir une manipulation native en Unicode. Cependant, il y a certains endroits où les InputStreams et les OutputStreams orientés-byte sont la solution adoptée ; en particulier, les bibliothèques java.util.zip sont orientées-byte plutôt qu'orientée-char. Donc l'approche la plus sage est d'essayer d'utiliser les classes Reader et Writer chaque fois que c'est possible, et vous découvrirez des situations où il vous faudra employer les bibliothèques orientées-byte parce que votre code ne se compilera pas.

\\\

Haut de page

///