Introduction
L’utilisation des fichiers en java nécessite plusieurs types différents d’objets. Il s’agit de mécanique très utile afin d’incorporer de la persistance de données dans les programmes, sans avoir besoin de base de donnée complexe.
La classe « File »
Avant de montrer comment lire et écrire dans les fichiers, il peut être intéressant de voir comment obtenir de l’information sur les fichiers. Une classe Java existe afin d’obtenir des informations sur les fichiers. Il s’agit de la classe java.io.File.
Il est à spécifier qu’un objet de type File peut être créé autant pour les fichiers standards que pour les répertoires.
Constructeur
Pour créer un objet de type File il faut envoyer le nom du fichier en argument du constructeur. Voici un exemple:
import java.io.File;
public class Programme {
public static void main(String[] aArguments) {
File lFichier = new File("test.txt");
...
}
}
Il est également possible de concaténer deux parties de chemin avec des constructeurs de File. Voici des exemples:
import java.io.File;
public class Programme {
public static void main(String[] aArguments) {
File lFichier = new File("/home/louis", "test.txt");
...
}
}
import java.io.File;
public class Programme {
public static void main(String[] aArguments) {
File lRepertoire = new File("/home/louis");
File lFichier = new File(lRepertoire, "test.txt");
...
}
}
Savoir si le fichier existe
Pour savoir si un fichier existe, on peut utiliser la méthode exists de la classe File. Cette méthode retourne une valeur booléenne (« True » si le fichier existe et « False » sinon). Par exemple:
import java.io.File;
public class Programme {
public static void main(String[] aArguments) {
File lFichier = new File("test.txt");
if (lFichier.exists()) {
System.out.println("Le fichier existe.");
} else {
System.out.println("Le fichier n'existe pas.");
}
}
}
Droit sur les fichiers
Dans un système d’exploitation, des mécanismes de protection de fichiers sont existes qui fait que les programmes exécutés par certains utilisateurs auront des droits spécifiques sur différents fichiers.
Les deux (2) types de protection de fichier existant en java sont les protections de lecture et d’écriture. Afin de valider ces deux (2) types de permission, on peut utiliser les méthodes de File suivante:
- boolean canRead(): Permet de vérifier que le fichier peut être lu;
- boolean canWrite(): Permet de vérifier que le fichier peut être modifié;
import java.io.File;
public class Programme {
public static void main(String[] aArguments) {
File lFichier = new File("test.txt");
if (lFichier.canRead()) {
System.out.println("Le fichier peut être lu.");
} else {
System.out.println("Le fichier ne peut pas être lu.");
}
if (lFichier.canWrite()) {
System.out.println("Le fichier peut être modifié.");
} else {
System.out.println("Le fichier ne peut pas être modifié.");
}
}
}
Accéder aux adresses des fichiers
Il existe plusieurs méthodes de File permettant d’obtenir des versions différentes de l’adresse et du nom d’un fichier. Voici certaines de ces méthodes:
- String getPath(): Retourne la même chaîne utilisée dans l’initialisation (adapté au système).
- String getCanonicalPath(): Retourne le chemin absolu d’un fichier. Utile lorsqu’un chemin relatif (ou un chemin inconnu) est utilisé dans la déclaration.
- String getParent(): Retourne le chemin du répertoire parent du fichier. Il est à noter qu’il existe également « File getParentFile() » qui retourne un objet « File » représentant le répertoire parent.
- String getName(): Retourne seulement la partie fichier du chemin. Par exemple, le « getName() » du fichier « /home/louis/test.txt » retournera « test.txt ». Il est à noter que cette méthode retourne la même chose que « toString() »
Manipulation de répertoires
Vérifier qu’un fichier est un répertoire
Il est possible de s’assurer qu’un objet de type File pointe vers un répertoire avec la méthode isDirectory().
Créer un répertoire
Avec un objet de type File, il est possible de créer des répertoires. Pour se faire, on utilise une des méthodes suivantes:
- mkdir(): Créer un répertoire (le répertoire parent doit exister);
- mkdirs(): Créer un répertoire ainsi que ses répertoires parents s’ils n’existent pas.
Par exemple:
import java.io.File;
public class Programme {
public static void main(String[] aArguments) {
File lRepertoire1 = new File("/home/louis");
File lRepertoire2 = new File(lRepertoire1, "test");
if (
lRepertoire1.exists() &&
lRepertoire1.isDirectory() &&
lRepertoire1.canWrite() &&
!lRepertoire2.exists()
) {
lRepertoire2.mkdir();
System.out.println("Répertoire créé");
} else {
System.out.println("Ne peut pas créer le répertoire " +
lRepertoire2.getAbsolutePath());
}
}
}
Lister les fichiers d’un répertoire
Il est possible de lister tous les fichiers contenues dans un répertoire en utilisant listFiles(). Voici un exemple:
public class Programme {
public static void main(String[] aArguments) {
File lRepertoire = new File("mon_repertoire");
File[] lFichiers = lRepertoire.listFiles();
for (File lFichier : lFichiers) {
System.out.println(lFichier.getName());
}
}
}
La manipulation de fichiers
Java permet plusieurs mécanismes afin de manipuler des fichiers. Peu importe le type de manipulation que vous effectuons, nous pouvons utiliser la classe File afin d’ouvrir un fichier. Malgré que les mécanismes de manipulation de fichier de java ne l’exigent pas (il est généralement possible d’utiliser directement l’adresse du fichier au lieu d’un objet File), c’est tout de même un bon réflex puisque ça permet de s’assurer que le fichier est valide avant de le manipuler.
Également, peu importe le type de manipulation à effectuer, il est important de ne pas oublier de fermer le fichier lorsqu’il n’est plus nécessaire. L’oublie de cette règle peut causer des bugs ou faire en sorte que des fichiers soient bloqués par le système d’exploitation.
Les types de fichiers
En Java (comme dans pas mal tous les autres langages), il est possible de gérer des fichiers textes ou des fichiers binaires. Nous nous concentrerons premièrement sur les fichiers textes et nous verrons plus bas comment gérer des fichiers binaires.
Les fichiers textes
Lors de la gestion de fichiers texte, Java s’arrange pour gérer par lui-même l’encodage des chaînes de caractère (UTF, Ascii, etc.) Il est donc assez simple de gérer ce type de fichier. Par contre, ce type de fichier a moins de fonctionnalité.
Écrire dans un fichier texte
Tout comme la lecture dans un fichier texte nécessite un objet spécial de type Scanner, écrire dans un fichier texte nécessite un objet spécial de type FileWriter. Le FileWriter permet d’écrire dans le fichier texte en envoyant le String à écrire à la méthode write. Il est important de placer l’utilisation du FileWriter dans un « try…catch » qui gère une exception de type IOException (ou de placer un « throws » dans la signature de la méthode). Voici un exemple:
import java.io.File;
import java.io.IOException;
import java.io.FileWriter;
public class Programme {
public static void main(String[] aArguments) {
File lFichier = new File("test.txt");
if (!lFichier.exists() || lFichier.canWrite()) {
try {
FileWriter lWriter = new FileWriter(lFichier);
lWriter.write("Salut\n");
lWriter.close();
} catch (IOException lException) {
System.out.println("Ne peut pas ouvrir le fichier en écriture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en écriture.");
}
}
}
Lire un fichier texte
Pour lire un fichier, il faut utiliser un Scanner. La gestion de ce type de scanner est similaire à la lecture d’entrée utilisateur au clavier. À noter que pour savoir s’il y a d’autres informations à lire, on peut utiliser les méthodes qui débutent par « hasNext…() » (par exemple, « hasNextLine() », « hasNextInt() », etc.) Il est important de placer l’utilisation du Scanner dans un « try…catch » qui gère une exception de type FileNotFoundException (ou de placer un « throws » dans la signature de la méthode). Par exemple:
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class Programme {
public static void main(String[] aArguments) {
File lFichier = new File("test.txt");
if (lFichier.canRead()) {
try {
Scanner lScanner = new Scanner(lFichier);
while (lScanner.hasNextLine()) {
System.out.println(lScanner.nextLine());
}
lScanner.close();
} catch (FileNotFoundException lException) {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
}
}
Les fichiers binaires
En fait, il n’y a pas réellement deux types de fichiers. Les fichiers binaires correspondent à tous les types de fichiers, sans exception. Les fichiers textes correspondent autant à des fichiers binaires que n’importe quels autres fichiers. On devrait plus dire qu’on manipule un fichier texte de manière texte ou de manière binaire.
Donc, les fichiers binaires sont tous les types de fichiers existants. La manipulation de ce type de fichier est souvent utilisée pour stocker des informations ayant une représentation très numérique. Par exemple, les fichiers d’images, correspondant généralement à des listes de valeurs de pixels (compressées ou non), sont stockés de manière binaire. Il en est de même pour les fichiers vidéos, les fichiers audio, les exécutables natifs, etc.
L’avantage de traiter les fichiers de manière binaire est que cela permet un contrôle absolu des informations stockées dans le fichier. Il est important de comprendre que toute manipulation texte d’un fichier est encodée et décodée en temps réel par les librairies en fonction d’un encodage standard (Ascii, Latin, UTF, etc.)
Puisque Java n’a pas été conçu pour traiter des pointeurs et des plages d’adresses binaires, il est nécessaire d’utiliser un objet de type ByteBuffer afin de transférer des valeurs Java en forme binaire.
Écrire dans un fichier binaire
Écrire de manière binaire dans un fichier nécessite l’utilisation d’un FileOutputStream. Il faut effectuer un write pour écrire une suite d’octet. Il faut envoyer un tableau (« Array ») de « byte » (ou « byte[] »). On utilise généralement la méthode array() de ByteBuffer. Voici un exemple:
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
public class Programme {
public List<Integer> fibonnaci(int aNombre) {
int lElement1 = 0, lElement2 = 1, i, lElementTemporaire;
List<Integer> lResultat = new ArrayList<Integer>(aNombre);
if (aNombre > 0) {
lResultat.add(Integer.valueOf(lElement1));
}
for (i = 1; i < aNombre; i = i + 1) {
lResultat.add(Integer.valueOf(lElement2));
lElementTemporaire = lElement2;
lElement2 = lElement2 + lElement1;
lElement1 = lElementTemporaire;
}
return lResultat;
}
public Programme() {
File lFichier = new File("test.bin");
if (!lFichier.exists() || lFichier.canWrite()) {
try {
OutputStream lWriter = new FileOutputStream(lFichier);
List<Integer> lFibonnaci = fibonnaci(10);
for (Integer lElement : lFibonnaci) {
ByteBuffer lBuffer = ByteBuffer.allocate(4); // Un int est de 4 octets.
lBuffer.putInt(lElement.intValue());
lWriter.write(lBuffer.array());
}
lWriter.close();
} catch (IOException lException) {
System.out.println("Ne peut pas ouvrir le fichier en écriture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en écriture.");
}
}
public static void main(String[] aArguments) {
new Programme();
}
}
Lecture dans un fichier binaire
De manière similaire à l’écriture d’un fichier de manière binaire, lire un fichier de manière binaire nécessite l’utilisation d’un FileInputStream. Il faut effectuer un read pour lire une suite d’octet dans un tableau de « byte ». Afin de convertir ce tableau de « byte » en d’autres type de donnée (« int », « float », etc.), il faut utiliser (en général), la méthode wrap(tableau) de ByteBuffer et utiliser les bons « getter » afin d’avoir le bon type. Voici un exemple:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
public class Programme {
public List<Integer> fibonnaci(int aNombre) {
int lElement1 = 0, lElement2 = 1, i, lElementTemporaire;
List<Integer> lResultat = new ArrayList<Integer>(aNombre);
if (aNombre > 0) {
lResultat.add(Integer.valueOf(lElement1));
}
for (i = 1; i < aNombre; i = i + 1) {
lResultat.add(Integer.valueOf(lElement2));
lElementTemporaire = lElement2;
lElement2 = lElement2 + lElement1;
lElement1 = lElementTemporaire;
}
return lResultat;
}
public Programme() {
File lFichier = new File("test.bin");
int lValeur;
boolean lFirst = true;
byte[] lByteArray = new byte[4];
if (lFichier.canRead()) {
try {
InputStream lReader = new FileInputStream(lFichier);
while(lReader.available() > 3) {
lReader.read(lByteArray);
ByteBuffer lBuffer = ByteBuffer.wrap(lByteArray);
if (lFirst) {
lFirst = false;
} else {
System.out.print(", ");
}
System.out.print(lBuffer.getInt());
}
System.out.print("\n");
lReader.close();
} catch (IOException lException) {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
}
public static void main(String[] aArguments) {
new Programme();
}
}
À propos des « little/big endian »
Parfois, les protocoles utilisés dans fichiers binaires nécessites la lecture de champs écrits en « little endian » au lieu d’en « big endian ». Par défaut, un ByteBuffer utilise l’ordre des octets par « big endian » (donc, dans l’ordre de lecture naturel). Afin de changer l’ordre de représentation des octets dans un ByteBuffer, il faut utiliser la méthode order avec une des constantes de la classe ByteOrder. Par exemple, voici un programme qui inscrit dans un fichier un entier en « little endian » et un second int en « big endian »:
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class Programme {
public static void main(String[] aArguments) {
File lFichier = new File("test.bin");
ByteBuffer lBuffer;
int lEntier1 = 1;
int lEntier2 = 2;
try {
OutputStream lStream = new FileOutputStream(lFichier);
lBuffer = ByteBuffer.allocate(4);
lBuffer.order(ByteOrder.LITTLE_ENDIAN);
lBuffer.putInt(lEntier1);
lStream.write(lBuffer.array());
lBuffer = ByteBuffer.allocate(4);
lBuffer.order(ByteOrder.BIG_ENDIAN);
lBuffer.putInt(lEntier2);
lStream.write(lBuffer.array());
lStream.close();
} catch (IOException laException) {
System.out.println("Ne peut pas écrire dans le fichier.");
}
}
}
Le résultat obtenu dans le fichier « test.bin » est le suivant (affiché avec un visualisateur hexadécimal):
Pour relire ces deux entiers, on pourrait utiliser un programme comme le suivant:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class Programme {
public static void main(String[] aArguments) {
File lFichier = new File("test.bin");
ByteBuffer lBuffer;
byte[] lBytes = new byte[4];
int lEntier1 = 1;
int lEntier2 = 2;
try {
InputStream lStream = new FileInputStream(lFichier);
lStream.read(lBytes);
lBuffer = ByteBuffer.wrap(lBytes);
lBuffer.order(ByteOrder.LITTLE_ENDIAN);
System.out.println("Le premier entier: " + lBuffer.getInt());
lStream.read(lBytes);
lBuffer = ByteBuffer.wrap(lBytes);
lBuffer.order(ByteOrder.BIG_ENDIAN);
System.out.println("Le second entier: " + lBuffer.getInt());
lStream.close();
} catch (IOException laException) {
System.out.println("Ne peut pas lire dans le fichier.");
}
}
}
Stocker et lire des Strings
L’utilisation du ByteBuffer fonctionne correctement pour stocker et charger des types primitifs (int, float, etc.), mais pas pour des Objets complexes. Stocker et charger un Objet complexe nécessite des mécanismes que nous ne verrons pas ici. Par contre, stocker et lire une chaîne de caractère se fait plus facilement que pour les autres types d’objets.
Stocker des objets String
Pour stocker une chaine de caractère dans un fichier on peut simplement utiliser la méthode getBytes de la classe String.
Voici un exemple minimaliste:
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Programme {
public Programme() {
File lFichier = new File("test.bin");
String lChaine = "Bonjour à tout le monde";
if (!lFichier.exists() || lFichier.canWrite()) {
try {
OutputStream lWriter = new FileOutputStream(lFichier);
lWriter.write(lChaine.getBytes());
lWriter.close();
} catch (IOException lException) {
System.out.println("Ne peut pas ouvrir le fichier en écriture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en écriture.");
}
}
public static void main(String[] aArguments) {
new Programme();
}
}
Par contre, si nous souhaitons stocker plsieurs chaîne de caractères dans un même fichier, il peut être difficile savoir où se termine une chaîne et où débute une autre. Pour se faire, il faut utiliser un protocol. Voici un exemple dans lequel un protocol permettant de stocker plus d’une chaîne est utilisé:
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
public class Programme {
private List<String> listeChaines() {
List<String> lResultat = new ArrayList<String>(10);
lResultat.add("La chaîne 0");
lResultat.add("Une belle chaîne 1");
lResultat.add("Toute une chaîne 2");
lResultat.add("C'est la chaîne 3");
lResultat.add("Ici la chaîne 4");
lResultat.add("Super chaîne 5");
lResultat.add("Super Grosse et dodu chaîne 6");
lResultat.add("La chîane 7 avec une erreur");
lResultat.add("La chaîne huit");
lResultat.add("La dernière chaîne 9");
return lResultat;
}
public Programme() {
File lFichier = new File("test.bin");
if (!lFichier.exists() || lFichier.canWrite()) {
try {
OutputStream lWriter = new FileOutputStream(lFichier);
List<String> lListeChaines = listeChaines();
for(String lChaine : lListeChaines) {
byte[] lChaineBytes = lChaine.getBytes();
ByteBuffer lBuffer = ByteBuffer.allocate(4);
lBuffer.putInt(lChaineBytes.length);
lWriter.write(lBuffer.array());
lWriter.write(lChaineBytes);
}
lWriter.close();
} catch (IOException lException) {
System.out.println("Ne peut pas ouvrir le fichier en écriture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en écriture.");
}
}
public static void main(String[] aArguments) {
new Programme();
}
}
Dans cet exemple, le nombre d’octets de la chaîne est stocké avant de stocker la chaîne en question. Ceci permettra à un programme qui doit recréer la liste de chaînes d’origine de séparer correctement les chaînes contenues dans le fichier (voir exemple plus bas).
Lire des objets String
Créer un String à partir d’un tableau de « byte » est très simple puisque la classe String a un constructeur servant exclusivement à cela. Voici un exemple qui peut être utilisé avec le fichier contenu dans le premier exemple de la section précédente (l’exemple minimaliste):
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Programme {
public Programme() {
File lFichier = new File("test.bin");
if (lFichier.canRead()) {
try {
InputStream lReader = new FileInputStream(lFichier);
byte[] lChaineBytes = new byte[lReader.available()];
lReader.read(lChaineBytes);
String lChaine = new String(lChaineBytes);
System.out.println(lChaine);
lReader.close();
} catch (IOException lException) {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
}
public static void main(String[] aArguments) {
new Programme();
}
}
Pour l’exemple plus complexe de la section précédente (celui avec le protocole permettant de stocker plus qu’une seule chaîne), voici l’exemple permettant d’obtenir la liste de chaîne:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
public class Programme {
private void afficherChaines(List<String> aListe) {
System.out.println("Les chaînes:");
for (String lChaine : aListe) {
System.out.println(" " + lChaine);
}
}
public Programme() {
File lFichier = new File("test.bin");
byte[] lIntBytes = new byte[4];
int lTailleChaine;
List<String> lListeChaines = new ArrayList<String>();
if (lFichier.canRead()) {
try {
InputStream lReader = new FileInputStream(lFichier);
while (lReader.available() > 3) {
lReader.read(lIntBytes);
lTailleChaine = ByteBuffer.wrap(lIntBytes).getInt();
byte[] lChaineBytes = new byte[lTailleChaine];
lReader.read(lChaineBytes);
lListeChaines.add(new String(lChaineBytes));
}
afficherChaines(lListeChaines);
lReader.close();
} catch (IOException lException) {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
}
public static void main(String[] aArguments) {
new Programme();
}
}
La classe FileChannel
Il est possible de gérer la position de lecture des objets « FileInputStream » et « FileOutputStream » en utilisant leur méthode getChannel(). Cette méthode retourne un objet de type FileChannel qui possède plusieurs méthodes utiles dans le contrôle de la position de lecture et d’écriture.
Voici les méthodes les plus pertinentes du FileChannel:
- position(): Retourne la position de lecture ou d’écriture en cours dans le fichier;
- position(int nouvellePosition): Change la position de lecture ou d’écriture dans le fichier à « nouvellePosition »;
- size(): Retourne la taille du fichier.
Voici un exemple utilisant la position de lecture dans un fichier et la taille du fichier:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.util.Scanner;
public class Programme {
private int lireOctet(FileInputStream aReader, int aPosition)
throws PositionInvalideException, IOException {
FileChannel lChannel = aReader.getChannel();
int lResultat = 0;
byte[] lIntBytes = new byte[4];
if (aPosition >= 0 && aPosition < lChannel.size()) {
lChannel.position(aPosition);
lResultat = aReader.read();
} else {
throw new PositionInvalideException("La position " + aPosition +
" n'est pas valide.");
}
return lResultat;
}
public Programme() {
File lFichier = new File("test.bin");
Scanner lScanner = new Scanner(System.in);
String lLigne;
int lPosition, lResultat;
if (lFichier.canRead()) {
try {
FileInputStream lReader = new FileInputStream(lFichier);
System.out.print("Entrez l'octet que vous voulez lire: ");
lLigne = lScanner.nextLine();
try {
lPosition = Integer.parseInt(lLigne);
try {
lResultat = lireOctet(lReader, lPosition);
System.out.println("L'octet à la position " +
lPosition + " est " + lResultat);
} catch (PositionInvalideException laException) {
System.out.println(laException.getMessage());
}
} catch (NumberFormatException laException) {
System.out.println("La valeur " + lLigne +
" n'est pas un entier valide.");
}
lReader.close();
} catch (IOException laException) {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
} else {
System.out.println("Ne peut pas ouvrir le fichier en lecture.");
}
}
public static void main(String[] aArguments) {
new Programme();
}
}
Pour information, l’exception « PositionInvalideException » est une exception de base implémentée comme ceci:
public class PositionInvalideException extends Exception {
public PositionInvalideException(String aMessage) {
super(aMessage);
}
}
Auteur: Louis Marchand
Sauf pour les sections spécifiées autrement, ce travail est sous licence Creative Commons Attribution 4.0 International.