|
Les entrées/sorties en Java
Nous allons dans ce chapitre étudier les principaux aspects liés aux flots de caractères. Nous allons voir que nous avons à notre disposition un grand nombre de services utilisables.
Les flots de caractères prédéfinis.
Il existe, comme dans d'autres langages, trois flots prédéfinis associés à l'entrée standard d'une application, sa sortie standard ainsi que sa sortie standard d'erreur. Ils sont respectivement nommés System.in, System.out et System.err. Nous pouvons d'ors et déjà dire que System.in est une instance de la classe BufferdInputStream, alors que les deux autres sont des instances de la classe
PrintStream.
try {
while((c = System.in.read()) != -1) {
System.out.print(c); nbc++;
}
catch(IOException e) { . . . } |
La classe java.io.File.
Cette classe permet de manipuler les fichiers. Pour ce faire, elle propose un certain nombre de méthodes fortes utiles. L'exemple suivant montre un exemple simple d'utilisation de cette classe. Il sera suivit d'un tableau contenant les principales méthodes utilisables.
File f = new File("fichier.mp3");
System.out.println(f.getAbsolutePath()+f.getName());
if (f.exists()) {
System.out.println(f.getName() + " : " +
(f.canRead()?"r":"-") +
(f.canWrite()?"w":"-") + " : " +
f.length() );
f.delete();
} |
| String getName() : retourne le nom |
| String getPath() : retourne la partie chemin |
| String getAbsolutePath() : idem mais en absolu |
| String getParent() : retourne le nom du repertoire parent |
| boolean renameTo(File newFile) : pour renommer un fichier |
| boolean exists() : est-ce que le fichier existe ? |
| boolean canRead() : est t-il lisible ? |
| boolean canWrite() : est t-il modifiable ? |
| long length() : quelle est sa longueur (en octets) |
| boolean delete() : on l'efface |
| boolean mkdir() : on créer un répertoire |
| String[] list() : on demande la liste des fichiers du répertoire |
Les classes de bases.
La classe InputStream.
C'est la classe la plus générique pour manipuler les flots d'entrées. Elle est abstraite et toute sous classe en dérivant se doit au moins implémenter la méthode read(). Les classe FileInputStream, DataInputStream, BufferedInputStream et quelques autres en dérivent.
La classe OutputStream.
De même que pour InputStream, OutputStream est une classe abstraite qui impose la définition d'une méthode write. Nous trouvons notamment, comme sous-classes, FileOutputStream, DataOutputStream, PrintStream et quelques autres.
La méthode flush permet d'écrire les tampons. La méthode close ferme le flot. A priori, ce n'est plus à vous de fermer les ressources, donc, vous n'avez normalement pas à utiliser cette commande (cela dépend de la version du JDK).
Lecture et écriture dans un fichier.
Pour ce faire, il faut obtenir un objet de classe File. Une fois cela fait, on peut soit créer un FileInputStream, soit un FileOutputStream. Il est clair que dans les deux cas, les méthodes proposées sont non facilement utilisables. Il suffit alors de créer de nouveaux objets de manipulation de flots de caractères à partir de ceux obtenus.
File f = new File("fichier.mp3");
FileInputStream fis = new FileInputStream(f);
DataInputStream dis = new DataInputStream(fis); |
Les autres classes les plus importantes.
Les exemples suivants montrent les classes les plus susceptibles d'être utilisées, ainsi que quelques méthodes applicables.
File f = new File("fichier.mp3");
FileInputStream fis = new FileInputStream(f);
DataInputStream dis = new DataInputStream(fis);
int a = dis.readInt();
short s = dis.readShort();
boolean b = dis.readBoolean(); |
File f = new File("fichier.mp3");
FileOutputStream fos = new FileOutputStream(f);
DataOutputStream dos = new DataOutputStream(fos);
int a = 10; dos.writeInt(a);
short s = 3; dos.writeShort();
boolean b = true; dos.writeBoolean(); |
File f = new File("fichier.mp3");
FileInputStream fis = new FileInputStream(f);
BufferedInputStream bis = new BufferInputStream(fis);
DataInputStream dis = new DataInputStream(bis);
FileOutputStream fos = new FileOutputStream(f);
BufferedOutputStream bos = new BufferedOutputStream(fos);
DataOutputStream dos = new DataOutputStream(bos); |
Du nouveau avec le JDK 1.1
Pour l'ensemble des classes précédentes, on travaille au niveau byte : donc avec des octets. Le JDK 1.1 introduit la notion de flot de caractères au niveau char (2 octets) en utilisant le format UNICODE.
Cela se traduit pas une nouvelle arborescence de classes, dont les deux classes principales sont les classes Reader et Writer. De ces deux classes en dérivent d'autres et notamment InputStreamReader (bufférisée par défaut), OutputStreamWriter (idem), FileReader (idem), FileWriter (idem), BufferedReader et BufferedWriter.
Deux classes sont utiles car elles permettent de faire le pont entre les deux arborescences : InputStreamReader et OutputStreamWriter.
La classe BufferedReader propose notamment une méthode très utilisée qui permet de sortir une ligne (au sens chaîne de caractères et donc se terminant par un retour chariot) d'un flot : la méthode String readLine(). La classe printWriter est, elle aussi, très utilisée ne serait-ce qu'avec System.out et System.err. Pour de plus amples informations, référez vous à la documentation du
JDK.
FileInputStream fis = new FileInputStream(f);
FileReader fr = new FileReader(new InputStreamReader(fis));
FileOutputStream fos = new FileOutputStream(f);
FileWriter fw = new FileWriter(new OutputStreamWriter(fos)); |
|
