La serialisation d'objet en Java

import javax.swing.JOptionPane;
import java.io.Serializable;

public class Personne implements Serializable {

    private String nom, prenom;
    private int age;

    public Personne() {
        nom = "Pas de nom";
        prenom = "Pas de prénom";
        age = 0;
    }

    public Personne(String nom, String prenom, int age) {
        this.nom = nom;
        this.prenom = prenom;
        this.age = age;
    }

    /* Affichage d'une personne en mode graphique */
    public void affichePersonne() {
        JOptionPane.showMessageDialog(null,
                "nom : " + nom + "\nPrenon : " + prenom + "\nage : " + age,
                "Personne",
                JOptionPane.INFORMATION_MESSAGE);
    }

/* Accesseurs et mutateurs */
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getPrenom() {
        return prenom;
    }

    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }
}

import java.io.ObjectOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

FileOutputStream monFichier = new FileOutputStream("fichier.dat");

ObjectOutputStream serial = new ObjectOutputStream(new FileOutPutStream("fichier.dat"));

import java.io.ObjectOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestSerialisation {

    public static void main(String[] args) throws IOException {
        
	/* 
         * On crée une nouvelle personne du nom de Squall Leonhart qui a 17 ans
         * On affiche ensuite cette personne (merci Swing)
         * Les informations sont conformes
         */
        Personne p = new Personne("Leonhart", "Squall", 17);
        p.affichePersonne();
        
        /*
         * On crée un objet de type ObjectOutputStream, qui prend un fichier en paramètre
         * La sérialisation commence tout de suite après
         * Grâce à la méthode writeObject() on sauvegarde l'état de l'objet passé en paramètre
         * la méthode flush() permet de vider le cache, elle est indispensable
         * On finit par fermer notre flux ObjectOutputStream
         */
        ObjectOutputStream serialise = new ObjectOutputStream(new FileOutputStream("fichier.dat"));
        
        serialise.writeObject(p);
        serialise.flush();
        serialise.close();
    }
}

import java.io.ObjectInputStream;
import java.io.FileInputStream;
import java.io.IOException;

FileInputStream monFichier = new FileInputSrteam("fichier.dat");

ObjectInputStream retour = new ObjectOutputStream(new FileInputStream("fichier.dat"));

import java.io.ObjectInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class TestSerialisation {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        /* Création d'un objet de type ObjectInputStream avec comme paramètre un fichier binaire */
        ObjectInputStream deserialise = new ObjectInputStream(new FileInputStream("fichier.dat"));

        /*
         * On crée ensuite une nouvelle Personne, que l'on nomme personne
         * Elle est initialisée avec la valeur de retour de la méthode readObject()
         * On effectue un cast car le retour de la méthode readObject est de type Object
         * Et on veut une Personne.
         * On utilise ensuite la méthode affichePersonne() de la classe Personne
         * Le résultat est conforme
         * On ferme le flux
         */
        Personne personne = (Personne) deserialise.readObject();
        personne.affichePersonne();
        deserialise.close();
    }
}

public class Personne implements Serializable {

    private String nom, prenom;
    /* L'attribut age ne sera pas sauvé, et il sera initialisé à null au chargement */
    private transient int age;
    // Reste de la classe
}

import java.beans.XMLEncoder;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;

XMLEncoder enc = new XMLEncoder(new FileOutputStream("fichier.xml"));

import java.beans.XMLEncoder;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;

public class TestSerialisation {

    public static void main(String[] args) throws FileNotFoundException {
    
    /*
     * On crée une nouvelle Personne et on l'affiche
     * On crée un nouvel objet de type XMLEncoder avec comme paramètre
     * un fichier XML
     * On "écrit" notre objet dans le fichier XML avec writeObject()
     * On vide le cache et force l'écriture
     * On finit par fermer l'objet (on libère la mémoire)
     */
    Personne p = new Personne("Loire", "Laguna", 27);
    p.affichePersonne();
    	
	XMLEncoder enc = new XMLEncoder(new FileOutputStream("fichier.xml"));
	enc.writeObject(p);
	enc.flush();
	enc.close();
	
    }
}

import java.beans.XMLDecoder;
import java.io.FileInputStream;

XMLDecoder decode = new XMLDecoder(new FileInputStream("fichier.xml"));

import java.beans.XMLDecoder;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class TestSerialisation {

    public static void main(String[] args) throws FileNotFoundException {
    
    /*
     * Création d'un objet de type XMLEncoder avec comme paramètre un fichier... XML
     * On crée une nouvelle personne grâce à la méthode readObject, n'oubliez pas le cast !
     * readObject est une méthode (aussi appelée fonction car elle renvoie quelque chose), qui 
     * renvoie un Object.
     * On ferme notre objet XMLDecoder, car nous n'en avons plus besoin
     * On affiche l'objet nouvellement créé ! Et le résultat est... conforme !	
     */
    XMLDecoder dec = new XMLDecoder(new FileInputStream("fichier.xml"));
    Personne p = (Personne) dec.readObject();
    dec.close();
    p.affichePersonne();
    }
}

public class TestSerialisation {

    public static void main(String[] args) {
    
    // SAUVEGARDE	
    	
    /* Création et affichage de deux objets de type Personne */
    Personne p1 = new Personne("Strife", "Clood", 21);
    Personne p2 = new Personne("Gainsborough", "Aeris", 22);
    p1.affichePersonne();
    p2.affichePersonne();
    
    /* Utilisation de la classe SauvegardeObjet */
    SauvegardeObjet.sauverVersXML(p1, "Clood.xml");
    SauvegardeObjet.serialiser(p2, "aeris.dat");
    
    /* p1 et p2 ne référencent plus rien ! */
    p1 = null;
    p2 = null;
    
    // CHARGEMENT
    
    /* Création de deux objets Personne à partir de la classe SauvegardeObjet */
    p1 = (Personne) SauvegardeObjet.chargerDepuisXML("cloud.xml");
    p2 = (Personne) SauvegardeObjet.deserialiser("aeris.dat");
    p1.affichePersonne();
    p2.affichePersonne();
    
    }
}