right

IV) LES API JAVA

3) Le package java.io

Les streams ou flux représentent un canal de communication. Il sont utilisés pour la lecture ou l'écriture
depuis un terminal, un fichier ou le réseau. Ils sont regroupés dans le paquetage java.io. Les streams
accessibles de façon classique sont des flots d'octets (byte).

3-1) InputStream et OutputStream

Les E/S standards sont des flots d'octets. Il sont accessibles comme des membres statiques (in, out et err) de la
classe java.lang.System.


InputStream stdin = System.in;

OutputStream stdout = System.out;

Le type réel de System.out est un sous-type de OutputStream, PrintStream, qui enveloppe le
stream. Pour lire ou écrire un ou plusieurs octets on dispose des interfaces read ou write qui sont
abstraites (définies dans les sous-classes particulières). Toutes les méthodes sur les streams peuvent renvoyer
IOException.


try

{

byte b;

int val = System.in.read();

if(val != -1)

b= (byte)val;

System.out.write(b);

}

catch(IOException e)

{

…

}

D'autres méthodes utiles sont aussi : available, skip, flush ou close.

3-2) Les enveloppes de flux

Pour faciliter leur utilisation, il est possible de positionner une enveloppe sur un flot.

3-2-1) Reader et Writer

Cette interface permet la lecture ou l'écriture directe de char en partant de la plupart des encodages connus sur un
octet.


Reader in = new InputStreamReader(System.in,8859_7);

try

{

char c;

int val = in.read();

if(val != -1)

c= (char)val;

}

3-2-2) DataInputStream et DataOutputStream

Permet de lire ou d'écrire des données des types simples dans un flot. Des méthodes pour l'accès aux types de
base sont disponibles.


DataInputStream in = new DataInputStream(System.in);

int i = in.ReadInt();

3-2-3) ObjectInputStream et ObjectOutputStream

Ces interfaces généralisent les précédentes en permettant de lire aussi des objets. Les objets écrits ou lus doivent
implémenter l'interface java.io.Serializable ou java.io.Externalizable.


ObjectInputStream p = new ObjectInputStream(new FileInputStream("tmp"));

int i = p.readInt();

String today = (String)p.readObject();

Date date = (Date)p.readObject();

p.close();

3-2-4) PrintReader ou PrintStream

Permet d'écrire de façon simple toute variable sous forme chaîne de caractères. Dans le cas des objets la méthode
toString (qui peut être masquée) est appelée. Contrairement aux autres flux il n'y a pas d'exception levée mais
une méthode checkError(). PrintStream fait les conversions de caractères par défaut en ISO8859-1.


PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out,

8859_1), true);

out.println(1);

out.println("un");

out.println(out);

3-3) Les tampons

Pour améliorer les performances des entrées-sorties il est préférable d'utiliser des tampons de lecture et d'écriture.
Un tel tampon peut permettre le marquage et le retour arrière pour certains flots qui ne le supportent pas par
défaut.


BufferInputStream bu = new BufferInputStream(System.in);

bu.mark(10);

3-4) Lecture de données sous forme de chaîne de caractères

Le filtre StreamTokenizer permet de lire de façon simple des valeurs numériques entrées sous forme de
chaîne de caractères.

 import java.io.*;

import java.util.*;

public class Polonaise

{

public static void main(String[] argv) throws IOException

{

Stack stack = new Stack();

Double value;

StreamTokenizer in = new StreamTokenizer(new

InputStreamReader(System.in));

in.wordChars('+','+');

in.wordChars('-','-');

in.wordChars('/','/');

in.wordChars('*','*');

in.eolIsSignificant(false);

do

{

in.nextToken();

if(in.ttype == StreamTokenizer.TT_NUMBER){

stack.push(new Double(in.nval));

}

if(in.ttype == StreamTokenizer.TT_WORD)

{

if(in.sval.length() == 1)

{

switch(in.sval.charAt(0))

{

case '+':

try

{

value = new Double(((Double)stack.pop()).doubleValue()

+ ((Double)stack.pop()).doubleValue());

stack.push(value);

System.out.println(value);

}

catch(EmptyStackException e)

{

System.out.println("Empty stack!");

}

break;

}

}

}

while(in.ttype != StreamTokenizer.TT_EOF);

}

}

3-5) Les tubes

Permet de créer deux flux (un de sortie et un d'entrée) reliés l'un à l'autre. Tout ce qui entre dans l'un ressort dans
l'autre.


PipedInputStream in = new PipedInputStream();

PipedOutputStream out = new PipedOutputStream(in);

3-6) Les fichiers

La classe File encapsule tous les accès relatifs aux fichiers.


File f = new File("toto");

if(f.isDirectory())

{

f.list();

}

Les classes FileReader, FileWriter, FileInputStream, FileOutputStream et
RandomAccessFile (accès en lecture ou en écriture) permettent d'accéder aux flux associés aux fichiers.


FileOutputStream fstream = new FileOutputStream(new File("toto"));

PrintStream pstream = new PrintStream(fstream);

pstream.println("toto");


Contactez-nous	Conditions d'utilisation	Qui sommes nous?
	© 2001 IsepFAQtory Tous droits réservés