Application

2
Flux Flots Fli Fla Flu ?
Flux
• Flux = Flots = Streams
• Source d’entrée ou puits
de sortie
• Séquence de données
(octets)
Stéphane HUOT
Dpt. Informatique
DUT Informatique - S3 - 2008
3
• Mode d’accès unifié à des ressources:
o
de types différents
4
Fichier
local
Fichier
distant
Flux
réseau
Flux
multimédia
...
• fichiers
o
binaires (propriétaire, images, audio, compressés,...)
o
texte (formatés ou non)
• flux réseau
• flux multimédia
FLUX D’ENTRÉE OU DE SORTIE
(INPUTSTREAM/OUTPUTSTREAM)
• ...
o
de provenances différentes
• locaux
• volatiles
FileInputStream
FileOutputStream
ObjectInputStream
ObjectOutputStream
AudioInputStream
AudioOutputStream
• distants
• Tout des séquences d’octets
Application
...InputStream
...OutputStream
5
• Le package java.io
• Les fichiers, la classe File
• Les classes abstraites de flux
• Accès unifié à des ressources différentes,
peu importe la représentation interne:
o
facilite la tâche du programmeur
o
améliore l’adaptabilité du code
o
permet l’indépendance de l’application vis-àvis des ressources
6
o
InputStream : flux d’entrée
o
OutputStream : flux de sortie
• Les classes dérivées
o
• Exemple: System.in et System.out
...
• Voir Javadoc
7
• Souvent nécessaires aux applications
o
o
pour lire des données
pour écrire des données
• Locaux (DD, périph ext., ...) ou
distants (réseau) : peu importe
• Fichiers binaires ou textuels
8
• java.io.File
• Représentation abstraite de chemins de
fichiers et de répertoires => descripteur
• Permet de :
o
créer, supprimer des fichiers/répertoires :
createNewFile(), delete(), ...
o
lire leurs propriétés :
exists(), isFile(), isDirectory(), canRead(),
canWrite(), listFiles(), ...
o
changer leur propriétés :
setReadable(boolean b), setWritable(), ...
9
package file;
10
private static void infosFichier(File f) {
1 if (f.exists())
2 System.out.println("- Le fichier " + f.getName() + " existe.");
3 else
4 System.out.println("- Le fichier " + f.getName() + " n'existe pas.");
5 if (f.isDirectory()) {
6 System.out.println("- Le fichier " + f.getName() + " est un répertoire qui
contient " + f.list().length + " fichiers/répertoires.");
7 }
8 else
9 System.out.println("- Le fichier " + f.getName() + " n'est pas un répertoire.");
10 System.out.println("- Le chemin absolu du fichier est " + f.getAbsolutePath());
11 System.out.println("- La taille du fichier est " + f.length() + " octets.");
12 if (f.isHidden())
13 System.out.println("- Le fichier " + f.getName() + " est caché.");
14 if (f.canRead())
15 System.out.println("- Le fichier " + f.getName() + " est lisible.");
16 if (f.canWrite())
17 System.out.println("- Le fichier " + f.getName() + " n'est pas protégé en
écriture.");
18 if (f.canExecute())
19 System.out.println("- Le fichier " + f.getName() + " est exécutable.");
20
System.out.println("***************************************");
import java.io.*;
public class ApplicationFile {
public static void main(String[] args) {
1 //création d'un objet File quelconque
2 File fichierTest = new File("fichierTest");
3 //lecture de ses informations
4 infosFichier(fichierTest);
5 //création d'un fichier représentant home directory de l'utilisateur
6 File home = new File(System.getProperty("user.home"));
7 //lecture des informations de chaque répertoire/fichier
8 for (File f : home.listFiles()) {
9 infosFichier(f);
}
}
//suite au prochain transparent
}
}
11
- Le fichier fichierTest n'existe pas.
- Le fichier fichierTest n'est pas un répertoire.
- Le chemin absolu du fichier est /Volumes/Warehouse/Work/Teaching/IUT/2007-2008/Java/Dev/CoursFlux/fichierTest
- La taille du fichier est 0 octets.
*****************************************************************************
- Le fichier .bash_history existe.
- Le fichier .bash_history n'est pas un répertoire.
- Le chemin absolu du fichier est /Users/Stuf/.bash_history
- La taille du fichier est 6000 octets.
- Le fichier .bash_history est caché.
- Le fichier .bash_history est lisible.
- Le fichier .bash_history n'est pas protégé en écriture.
*****************************************************************************
- Le fichier Sites existe.
- Le fichier Sites est un répertoire qui contient 4 fichiers/répertoires.
- Le chemin absolu du fichier est /Users/Stuf/Sites
- La taille du fichier est 204 octets.
- Le fichier Sites est lisible.
- Le fichier Sites n'est pas protégé en écriture.
- Le fichier Sites est exécutable.
*****************************************************************************
- Le fichier test.des existe.
- Le fichier test.des n'est pas un répertoire.
- Le chemin absolu du fichier est /Users/Stuf/test.des
- La taille du fichier est 239 octets.
- Le fichier test.des est lisible.
- Le fichier test.des n'est pas protégé en écriture.
*****************************************************************************
12
• La classe abstraite InputStream pour lire:
o
abstract int read(): lit l’octet suivant, -1 sinon
o
int read(byte[] b): remplit le tableau
o
...
• La classe abstraite OutputStream pour écrire:
o
abstract void write(byte b): écrit l’octet b
o
void write(byte[] b): écrit les octets
o
...
• Peuvent lever IOException
13
14
• Classes concrètes: FileInputStream et
FileOutputStream
• exemple, lecture d’un fichier en entier:
1. Création du flux (entrée ou sortie):
• instanciation d’un objet d’une classe concrète qui étend
InputStream ou OutputStream (selon le type du flux)
• la source du flux est en général passée en paramètre du
constructeur (chemin ou descripteur de fichier, URL/URI, flux
réseau, ...)
1 try {
2
InputStream in = new FileInputStream("donnees.dat");
3 byte[] donnees = new byte[in.available()];
4 in.read(donnees);
5 in.close();
6
System.out.println(donnees.length + " octets ont été lus.");
7 } catch (Exception e) {
8 System.err.println(e.getMessage());
9 }
• le flux est ouvert (en lecture ou écriture) à la construction
de l’objet (modulo problème => exception)
2. Utilisation du flux
• lecture (méthodes read) ou écriture (méthodes write)
3. Fermeture du flux
• méthode close()
15
16
• Lecture par octet:
• Ecriture identique avec les méthodes write
1try {
2
InputStream in = new FileInputStream("donnees.dat");
3 int donnee;
4 while ((donnee = in.read()) != -1) {
5 System.out.println("Octet lut: " + donnee);
6 }
7 in.close();
8} catch (Exception e) {
9 System.err.println(e.getMessage());
}
10
• Lecture/écriture avec un buffer
o
BufferedInputStream et BufferedOutputStream
o
BufferedInputStream bin = new BufferedInputStream(new
FileInputStream("donnees.dat"));
• Lecture/écriture de données typées (Boolean,
Double, ...)
o
DataInputStream (readBoolean(), ...) et DataOutputStream
o
DataInputStream din = new DataInputStream(new
FileInputStream("donnees.dat"));
• Voir Javadoc...
17
• Fichiers binaires avec un encodage
particulier: jeu de caractères
• Lecture par ligne:
1 try {
2
BufferedReader inText = new BufferedReader(new InputStreamReader(new
FileInputStream("donnees.txt")));
3 String ligne;
4 while ((ligne = inText.readLine()) != null) {
5 System.out.println("La ligne lue est: " + ligne);
6 }
7
inText.close();
8 } catch (Exception e) {
9 System.err.println(e.getMessage());
10}
• Lecture/écriture:
o
toujours avec des InputStream et OutputStream
o
interprétation de l’encodage:
InputStreamReader et InputStreamWriter ou
BufferedReader et BufferedWriter (tampon et
lecture/écriture par ligne)
18
• Lecture par caractère(s):
int read() et int read(char[] cbuf, int off, int
len)
19
1 try {
2
BufferedWriter outText = new BufferedWriter(new
OutputStreamWriter(new FileOutputStream("donnees.txt")));
3 outText.write("Première ligne\n");
4 String ligne2 = "Seconde ligne";
5 outText.write(ligne2 + "\n");
6 outText.close();
7 } catch (Exception e) {
8 System.err.println(e.getMessage());
9 }
20
• Classes de bases: implantations de InputStream/
OutputStream
• Ajout d’un buffer: BufferedInputStream/
BufferedOutputStream, à partir d’un InputStream/
OutputStream
• Ajout de l’interprétation de caractères:
InputStreamReader/OutputStreamWriter, à partir
d’un InputStream/OutputStream
• Encapsulation pour de nouvelles capacités (pattern
decorator)
• voir Javadoc...
21
• Pour lire/écrire des flux pré-formatés
(HTML, XML, ...)
• Pour sauver/charger des objets Java
(sérialisation)
• Lire et écrire des archives (zip et jar)
• Lire et écrire des images
• ...
22
• eXtended Markup Language
• Fichiers textuels formatés (balises)
• Cohérence et vérification du format (DTD
et schémas)
• Format d’échange très répandu
(applications, BD, Web, ...)
• Java fournit des outils pour lire et écrire
(parseurs SAX et DOM auxquels on
attache des ‘Streams’)
23
24
• Tous les attributs à sérialiser doivent euxmême implanter Serializable
• packages java.util.zip et java.util.jar
• Permettent de compresser et décompresser
• Descripteurs particuliers: ZipFile et
JarFile
• Descripteurs des données internes:
ZipEntry et JarEntry
• Utilisation des classes ObjectInputStream et
ObjectOutputStream pour lire et écrire
(readObject et writeObject)
• Flux pour lire et écrire: ZipInputStream et
ZipOutputStream, JarInputStream et
JarOutputStream
• Persistance des données
• Ecriture/lecture directe d’objets (instances) de
l’application dans des flux (fichiers, réseau, ...)
• Les classes doivent implanter l’interface
Serializable
25
- Accès unifié aux res
sources:
flux d’octets
- Ouvrir, utiliser, ferme
r
- Décoration des InputS
tream et
OutputStream de base
pour des
fonctionnalités supplé
mentaires