Programmation Orientée Objet
JAVA
Chapitre N°6
Utilisation des API Standards
Les Classes du package [Link]
Les Fichiers
Par SAIR ABDELLAH
[Link]@[Link]
Entrées / Sorties: Les classe flux
Les classes flux :
Un programme a souvent besoin d’échanger des
informations pour recevoir une source ou pour envoyer
des données vers un destinataire.
La source et la destination peuvent être de natures
multiples: fichier, base de données, ou autre programme,
etc.
La nature des données échangées peut également être
diverse: texte, images, son, etc.
Entrée: le programme lit (reçoit) des données de
l’intérieur.
Sortie: le programme écrit (envoie) des données vers
l’extérieur.
Vue générale sur les classes flux :
Un flux (stream) permet d’encapsuler des
processus pour l’envoi et la réception de données.
Un flux traite toujours les données de façon
séquentielle.
Par rapport à la direction du flux, on peut ranger
les flux en deux familles:
Les flux d’entrée.
Les flux de sortie.
Par rapport à la nature des données manipulées,
on peut diviser les flux en deux grandes
catégories:
Les flux de caractères.
Les flux d’octets ou flux binaires.
Vue générale sur les classes flux :
Java définit des classes flux pour lire ou écrire
des données mais aussi des classes pour
traiter les données du flux.
Ces classes doivent être associées à un flux de
lecture ou d’écriture et sont considérées
comme des filtres.
Les classes de flux
Toutes les classes de manipulation de flux sont
dans le package [Link].
Pour bien choisir une classe adaptée à un
traitement donné, il faut comprendre la
dénomination des différentes classes.
Il existe quatre suffixes possibles selon le type
du flux (flux de caractères ou flux d’octets) et le
sens du flux (flux d’entrée ou flux de sortie).
Les classes de flux
Il existe donc quatre hiérarchies de
classes qui encapsulent des flux
particuliers.
les sous classes de Reader sont des types de flux
en lecture sur les caractères,
les sous classes deWriter sont des types de flux
en écriture sur les caractères,
les sous classes de InputStream sont des types
de flux en lecture sur les octets,
les sous classe de OutputStream sont des types
de flux en écriture sur les octets.
Les classes flux de caractères
Ces flux transportent des données sous forme
de caractères et utilisent le format Unicode qui
code les informations sur 2 octets.
Les classes qui gèrent les flux de caractères
héritent d’une des deux classes abstraites
Reader et Writer.
La classe Reader
C’est une classe abstraite qui est la classe de base
de toutes les classes qui gèrent des flux texte
d’entrée.
Quelques méthodes:
void close() // ferme le flux et libère les ressources qui lui étaient
associées
int read() // renvoie le caractère lu et -1 si la fin du flux est atteinte
boolean ready() // indique si le flux est prêt à être lu
La classe [Link]
Cette classe permet de gérer les fichiers texte
d’entrée.
Elle dispose des mêmes fonctionnalités que la classe
abstraite Reader.
Il faut souvent la coupler à un objet de la classe
BufferedReader qui possède des méthodes plus
appropriées et complètes à la manipulation de fichiers
textes en lecture.
Telle que : String readLine ( ) pour la lecture d’une ligne.
Parmi les constructeurs de FileReader, on peut
distinguer:
FileReader (File objectFile)
FileReader (String fileName)
Lecture d’un fichier texte
Pour lire le fichier texte [Link] situé dans le répertoire D:\[Link]
on procède comme suit:
//On lie le fichier à un flux d’entrée
FileReader fichier = new FileReader("D:/[Link]");
/*Pour utiliser des méthodes plus évoluées, on encapsule ce flux dans un
filtre:
*/
BufferedReader buffer = new BufferedReader(fichier);
//On parcourt le filtre pour afficher le contenu du fichier:
String ligne_lue = [Link]( ) ;
while (ligne_lue != null ){
[Link] (ligne_lue) ;
ligne_lue = [Link] ( ) ;
}
[Link] ( ) ;
[Link]( ) ;
La classe Writer
La classe [Link]
La classe [Link]
Ecriture dans un fichier texte
La classe [Link]
La classe [Link]
La classe [Link]
Exemple PrintWriter
La classe [Link]
La classe File permet la gestion des fichiers et des répertoires
(création, suppression, renommage, copie, etc.….).
L’instruction File monfichier = new File ("c:/[Link]");
crée un objet monfichier associé au fichier [Link], mais
elle ne crée pas le fichier texte (ie [Link] ).
On peut vérifier l’existence d’un fichier avec la méthode
boolean exists ().
Si le fichier [Link] n’existait pas, il serait possible de le
créer explicitement sur disque en utilisant la méthode
createNewFile ( ) qui renvoie un booléen ( true si la création
a réussi, false sinon):
[Link] () ;
Exemple de création d’un fichier
import [Link];
import [Link];
public class CreerFile {
public static void main(String[] args) {
File f = new File(“c:/[Link]");
[Link] .println([Link]());
// false car [Link] n’existe pas encore
try {
boolean creation = [Link] ();// [Link] est créé
}
catch (IOException ex)
{[Link];println([Link]());}
[Link] .println ([Link]());
//true car [Link] existe maintenant
}
}
Méthodes de la classe File
Méthodes de la classe File
Méthodes de la classe File