Les flux d'entrées / sorties (1/2)

//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("test.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 ! !
			}
		}		
	}
}

//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("test.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();
        }     	
    }
}

FileInputStream fis = new FileInputStream(new File("toto.txt"));
DataInputStream dis = new DataInputStream(fis);
BufferedInputStream bis = new BufferedInputStream(dis);

//Ou en condensé : 
//BufferedInputStream  bis = new BufferredInputStream(new DataInputStream(FileInputStream(new File("toto.txt"))));

//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("test.txt"));
                bis = new BufferedInputStream(new FileInputStream(new File("test.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();
        }     	
    }
}

//Package à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
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;
        BufferedInputStream bis;
        BufferedOutputStream bos; 
        
        try {
        	fis = new FileInputStream(new File("test.txt"));
        	fos = new FileOutputStream(new File("test2.txt"));
        	bis = new BufferedInputStream(new FileInputStream(new File("test.txt")));
                bos = new BufferedOutputStream(new FileOutputStream(new File("test3.txt")));
                byte[] buf = new byte[8];
                
                //On récupère le temps du system
                long startTime = System.currentTimeMillis();
                
                while(fis.read(buf) != -1){
                	fos.write(buf);
                }
                //On affiche le temps d'exécution
                System.out.println("Temps de lecture + écriture avec FileInputStream et FileOutputStream : " + (System.currentTimeMillis() - startTime));
                
                //On réinitialise                
                startTime = System.currentTimeMillis();

                while(bis.read(buf) != -1){
                	bos.write(buf);
                }
                //On réaffiche
                System.out.println("Temps de lecture + écriture avec BufferedInputStream et BufferedOutputStream : " + (System.currentTimeMillis() - startTime));
                
                //On ferme nos flux de données
                fis.close();
                bis.close();
                
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }     	
    }
}

//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();
        }     	
	}
}

//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 à 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();
        }     	
     }
}

public class Notice {
	private String langue ;
	public Notice(){
		this.langue = "Français";
	}
	public Notice(String lang){
		this.langue = lang;
	}
	public String toString() {
		return "\t Langue de la notice : " + this.langue + "\n";
	}
}

import java.io.Serializable;

public class Game implements Serializable{
	private String nom, style;
	private double prix;
	private Notice notice;
	
	public Game(String nom, String style, double prix) {
		this.nom = nom;
		this.style = style;
		this.prix = prix;
		this.notice = new Notice();
	}
	
	public String toString(){
		return 	"Nom du jeu : " + this.nom + 
				"\nStyle de jeu : " + this.style + 
				"\nPrix du jeu : " + this.prix + 
				"\n";
	}	
}

import java.io.Serializable;

public class Game implements Serializable{
	private String nom, style;
	private double prix;
	//Maintenant, cette variable ne sera pas sérialisée
	//Elle sera tout bonnement ignorée ! !
	private transient Notice notice;
	
	public Game(String nom, String style, double prix) {
		this.nom = nom;
		this.style = style;
		this.prix = prix;
		this.notice = new Notice();
	}
	
	public String toString(){
		return 	"Nom du jeu : " + this.nom + 
				"\nStyle de jeu : " + this.style + 
				"\nPrix du jeu : " + this.prix +
				"\n";
	}	
}

import java.io.File;
import javax.swing.filechooser.FileFilter;

public class ZFileFilter extends FileFilter {

	private String extension = ".sdz", description = "Fichier Ardoise Mazique";
	
	public ZFileFilter(String ext, String descrip){
		this.extension = ext;
		this.description = descrip;
	}
	
	public boolean accept(File file){
		return (file.isDirectory() || file.getName().endsWith(this.extension));
	}
	
	public String getDescription(){
		return this.extension + " - " + this.description;
	}	
}