Objet File
//Package à importer afin d'utiliser l'objet File
import java.io.File;
public class Main {
public static void main(String[] args) {
//Création de l'objet File
File f = new File("test1.txt");
System.out.println("Chemin absolu du fichier : " +
f.getAbsolutePath());
System.out.println("Nom du fichier : " + f.getName());
System.out.println("Est-ce qu'il existe ? " + f.exists());
System.out.println("Est-ce un répertoire ? " + f.isDirectory());
System.out.println("Est-ce un fichier ? " + f.isFile());
System.out.println("Affichage des lecteurs racines du PC : ");
for(File file : f.listRoots())
{
System.out.println(file.getAbsolutePath());
try {
int i = 1;
//On parcourt la liste des fichiers et répertoires
for(File nom : file.listFiles()){
//S'il s'agit d'un dossier, on ajoute un "/"
System.out.print("\t\t" + ((nom.isDirectory()) ?
nom.getName()+"/" : nom.getName()));
if((i%4) == 0){
System.out.print("\n");
}i
++;
}
System.out.println("\n");
} catch (NullPointerException e) {
//L'instruction peut générer un NullPointerException s'il n'y a
//pas de sous-fichier ! !
}
}
}
}
Les objets FileInputStream et FileOutputStream
//Package à importer afin d'utiliser les objets
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
//Nous déclarons nos objets en dehors du bloc try/catch
FileInputStream fis;
FileOutputStream fos;
try {
//On instancie nos objets.
//fis va lire le fichier et
//fos va écrire dans le nouveau !
fis = new FileInputStream(new File("test1.txt"));
fos = new FileOutputStream(new File("test2.txt"));
//On créer un tableau de byte
//pour dire de combien en combien on va lire les données
byte[] buf = new byte[8];
//On crée une variable de type int
//pour affecter le résultat de la lecture
//retourne -1 quand c'est fini
int n = 0;
//Tant que l'affectation dans la variable est possible, on boucle.
//Lorsque le fichier est terminé, l'affectation n'est plus possible !
//Donc on sort de la boucle.
while((n = fis.read(buf)) >= 0)
{
//On écrit dans notre deuxième fichier
//avec l'objet adéquat
fos.write(buf);
//On affiche ce qu'a lu notre boucle
//au format byte et au format char
for(byte bit : buf)
System.out.print("\t" + bit + "(" +
(char)bit + ")");
System.out.println("");
}
//On ferme nos flux de données
fis.close();
fos.close();
System.out.println("Copie terminée !");
} catch (FileNotFoundException e) {
//Cette exception est levée
//si l'objet FileInputStream ne trouve aucun fichier
e.printStackTrace();
} catch (IOException e) {
//Celle-ci se produit lors d'une erreur
//d'écriture ou de lecture
e.printStackTrace();
}
}
}
Maintenant, voici un code qui permet de tester le temps d'exécution de la lecture :
//Package à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
//Nous déclarons nos objets en dehors du bloc try/catch
FileInputStream fis;
BufferedInputStream bis;
try {
fis = new FileInputStream(new File("test1.txt"));
bis = new BufferedInputStream(new
FileInputStream(new File("test1.txt")));
byte[] buf = new byte[8];
//On récupère le temps du système
long startTime = System.currentTimeMillis();
//Inutile de faire des traitements dans notre boucle
while(fis.read(buf) != -1);
//On affiche le temps d'exécution
System.out.println("Temps de lecture avec FileInputStream : " + (System.currentTimeMillis() - startTime));
//On réinitialise
startTime = System.currentTimeMillis();
//Inutile de faire des traitements dans notre boucle
while(bis.read(buf) != -1);
//On réaffiche
System.out.println("Temps de lecture avec BufferedInputStream : " + (System.currentTimeMillis() - startTime));
//On ferme nos flux de données
fis.close();
bis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Utilisation de Data(Input/Output)Stream
//Package à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
//Nous déclarons nos objets en dehors du bloc try/catch
DataInputStream dis;
DataOutputStream dos;
try {
dos = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(
new File("sdz.txt"))));
//Nous allons écrire chaque primitif
dos.writeBoolean(true);
dos.writeByte(100);
dos.writeChar('C');
dos.writeDouble(12.05);
dos.writeFloat(100.52f);
dos.writeInt(1024);
dos.writeLong(123456789654321L);
dos.writeShort(2);
dos.close();
//On récupère maintenant les données !
dis = new DataInputStream(
new BufferedInputStream(
new FileInputStream(
new File("sdz.txt"))));
System.out.println(dis.readBoolean());
System.out.println(dis.readByte());
System.out.println(dis.readChar());
System.out.println(dis.readDouble());
System.out.println(dis.readFloat());
System.out.println(dis.readInt());
System.out.println(dis.readLong());
System.out.println(dis.readShort());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
La sérialisation : les objets ObjectInputStream et
ObjectOutputStream
nous allons créer deux ou trois objets Game ;
nous allons les sérialiser dans un fichier de notre choix ;
nous allons ensuite les dé-sérialiser afin de pouvoir les réutiliser.
package monpackage;
//package à importer
import java.io.Serializable;
public class Game implements Serializable{
private String nom, style;
private double prix;
public Game(String nom, String style, double prix) {
this.nom = nom;
this.style = style;
this.prix = prix;
}
public String toString(){
return "Nom du jeu : " + this.nom +
"\nStyle de jeu : " + this.style +
"\nPrix du jeu : " + this.prix +
"\n";
}
}
package monpackage;
//Package à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Main {
public static void main(String[] args) {
//Nous déclarons nos objets en dehors du bloc try/catch
ObjectInputStream ois;
ObjectOutputStream oos;
try {
oos = new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream(
new File("game.txt"))));
//Nous allons écrire chaque objet Game dans le fichier
oos.writeObject(new Game("Assassin Creed", "Aventure",
45.69));
oos.writeObject(new Game("Tomb Raider", "Plateforme",
23.45));
oos.writeObject(new Game("Tetris", "Stratégie", 2.50));
//NE PAS OUBLIER DE FERMER LE FLUX ! ! !
oos.close();
//On récupère maintenant les données !
ois = new ObjectInputStream(
new BufferedInputStream(
new FileInputStream(
new File("game.txt"))));
try {
System.out.println("Affichage des jeux :");
System.out.println("*************************\n");
System.out.println(((Game)ois.readObject()).toString());
System.out.println(((Game)ois.readObject()).toString());
System.out.println(((Game)ois.readObject()).toString());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
ois.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
