Conservation des données d'une hastable

Version imprimable

17/11/2009, 14h23
vegange

HELP ! Conservation des données d'une hastable

:lol: bonjour à tous..voilà mon probleme du jour :

j'ai creer une petit programme qui stocke nom,prenom,age (pour me familiariser avec les fonctions et la hastable) dans une hastable qui marche bien mais quand je ferme le programme, tout disparait. mais mon but et de conserver les données une fois le programme fermer puis de réenregistrer d'autres données. comment faire pour conserver les données d'un hastable:roll:
17/11/2009, 14h49
visiwi

Salut,

Il faut stocker les infos, dans un fichier ou une bdd.
Voici un tuto qui t'aidera surement.
17/11/2009, 16h38
hibour

Regarde la Sérialisation
Il faut sauvegarder les données dans un fichier car c'est la seule chose qui est persistante.
Tu va écrire ton objet hashtable avec un truc dans le genre

Code:

objectOutputStream.write(tonObjet)

et pour le restituer tu utilise

Code:

Hashtable obj = (Hashtable ) objectInputStream.read(fileInputStream)

Regarde http://java.sun.com/j2se/1.4.2/docs/...putStream.html
18/11/2009, 13h26
vegange

:D merci pour vos reponses, je vais etudier tout çà et je vous dirais ce que cela donne

:mrgreen: me voici de retour, j'ai bien regarder le tuto "serialisation" http://ydisanto.developpez.com/tutor...ation/partie1/

l'on a une classe personne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.io.Serializable;
 
public class Personne implements Serializable {
	static private final long serialVersionUID = 6L;
	private String nom;
	private String prenom; 
	private Integer age;
 
	public Personne(String nom, String prenom, Integer age) {
		this.nom = nom;
		this.prenom = prenom;
		this.age = age;
	}
 
	public String toString() {
		return nom + " " + nom + " " + age + " ans";
	} 
}

et une classe SerializationMain.java

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
 
public class SerializationMain {
 
	static public void main(String ...args) {
		try {
			// création d'une personne
			Personne p = new Personne("Dupont", "Jean", 36);
			System.out.println("creation de : " + p);
 
			// ouverture d'un flux de sortie vers le fichier "personne.serial"
			FileOutputStream fos = new FileOutputStream("personne.serial");
 
			// création d'un "flux objet" avec le flux fichier
			ObjectOutputStream oos= new ObjectOutputStream(fos);
			try {
				// sérialisation : écriture de l'objet dans le flux de sortie
				oos.writeObject(p); 
				// on vide le tampon
				oos.flush();
				System.out.println(p + " a ete serialise");
			} finally {
				//fermeture des flux
				try {
					oos.close();
				} finally {
					fos.close();
				}
			}
		} catch(IOException ioe) {
			ioe.printStackTrace();
		}
	}
}

dans la classe SerializationMain.java, on instancie directement la personne , puis on creer le flux. OK....

or dans ma conception, j'ai plusieurs classes :

classe personne on je cree :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//le but de ce programme est enregistrer un nom, de faire une hastable et de l'enregistrer dans un fichier
public class Personne {
 
	/**
         * @param args
         */
	private String nom;//variable prive declaré en format chaine 
 
	/*
	 * contructeur de la classe personne
	 * definit, le nom=nom
	 * 
	 */
	public Personne(String nom){
		this.nom=nom;
	}
	/*
	 * fonction getNom qui return le nom de la personne
	 */
	public String getNom(){
		return nom;
	}
	/*
	 * procedure affichePersonne qui affiche le nom
	 */
	public void affichepersonne(){
		System.out.println(" Nom : "+getNom());
	}
}

une classe Presentation on je mets ma hastable et les methodes , ajout,afficher, et supprimer un nom, donc j'ai un IHM en mode console qui gere le nom, mais quand je ferme l'application je recommence tout

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import java.util.Enumeration;
import java.util.Hashtable;
public class Presentation {
 
	//Hashtable pour stocker les personnes
	static Hashtable <String,Personne> tabPersonne;
 
	public Presentation (){
	tabPersonne = new Hashtable<String,Personne>();
	IHMPresentation .afficherMenu();
	}
 
	/**Methode pour ajouter une personne à la liste
         * @param ident
         * @param pers
         * @return
         */
	public static boolean ajouterPersonne(String ident,Personne pers){
		tabPersonne.put(ident,pers);
		return true;
	}
 
	public static boolean supprimerPersonne(String ident) 
	{	
		if (tabPersonne.containsKey(ident))
		{
			tabPersonne.remove(ident);
			return true;
		}
		else
			return false;
	}
	/** Methode qui renvoie une personne en fonction de son ident
         * @param ident
         * @return personne de l'identifiant
         */
	public static Personne getPersonne (String ident){
		if (indentPersonneDisponible(ident)) 
			return null;
		else
			return tabPersonne.get(ident);
	}
	/** Méthode listant toutes les personnes
         */
	public static void afficherPersonne(){
		System.out.println("La liste contient :"+tabPersonne.size()+" personne(s)");
		System.out.println("———————————————————————————————————————————————————————————\n\n");
		Enumeration enumIdentPersonne = tabPersonne.keys();
		String cle;
		Personne personneLu =null;
		while(enumIdentPersonne.hasMoreElements())
		{
			cle=(String)enumIdentPersonne.nextElement();
 
			System.out.println("Clé : "+cle);
			System.out.println("————————————————");
			personneLu=tabPersonne.get(cle);
			personneLu.affichepersonne();		
			System.out.println();
		}
	}
	/** Methode qui vérifie si l'identifiant n'est pas déjà utilisé
         * @param ident
         * @return disponibilité de l'ident
         */
	public static boolean indentPersonneDisponible(String ident){
		if (ident.equals("0"))return true;
		else return !tabPersonne.containsKey(ident);
	}
 
}

ma question est : OU DOIS-JE AJOUTER LE FLUX POUR ENREGISTRER LES DONNES DANS MA HASTABLE QUAND LE PROGRAMME FERME;

pouvez vous me dire ou ajouter le flux dans mon fichier ?:?

:roll: je bloque car je n'arrive pas a integrer mon objet dans :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.io.FileOutputStream;//pour la serialisation (entree)
import java.io.IOException;//pour la serialisation et deserialisation
import java.io.ObjectOutputStream;//pour la serialisation
//import java.io.FileInputStream;//pour la deserialisation (sortie)
//import java.io.ObjectInputStream;//pour la deserialisation
public class ApplicationPersonne {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Raccord de méthode auto-généré
		//programme principal appelant la presentation Personne
		new Presentation();
		/*
		 * ici la serialisation creation du fichier en entree des noms
		 */
		try {
				// création d'une personne
				ICI JE DOIS METTRE MON OBJET
								; 
				System.out.println("creation de :"+OBJET);

				// ouverture d'un flux de sortie vers le fichier "personne.serial"
				FileOutputStream fos = new FileOutputStream("nom.serial");

				// création d'un "flux objet" avec le flux fichier
				ObjectOutputStream oos= new ObjectOutputStream(fos);
				try {
					// sérialisation : écriture de l'objet dans le flux de sortie
					oos.writeObject(OBJET); 
					// on vide le tampon
					oos.flush();
					System.out.println(OBJET);
				} finally {
					//fermeture des flux
					try {
						oos.close();
					} finally {
						fos.close();
					}
				}
			} catch(IOException ioe) {
				ioe.printStackTrace();
			}
	}
}

la , je bloque car dans le tuto on donne l'exemple avec une instanciation de l'objet mais dans ma creation j'ai creer une methode ajouter() qui enregistre le nom au clavier.
aidez moi s'il vous plait ???????

:mrgreen: je cherche toujours la consevation de mes données dans ma hastable et malgré mes recherches qui m'ont permis de trouver comment serialisé et deserialisé mes données des que je ferme eclispe , rien.

je vous explique :

je creee une petite application qui enregistre le nom d'une personne dans une hastable avec bien sur un identifiant. je suis en mode console et j'ai un ihm du style :

GESTION FICHE

1) Ajouter le nom 2) Lister le(s) nom (s)
3) Afficher le(s) nom (s)

4) Supprimer un nom

j'ai donc une classe

Personne,Persentation,IHMPresentation,ApplicationPersonne

la classe personne definit le contructeur de personne avec le nom et une fonction qui return le nom

la classe presentation les methodes que l'on appellera dans l'ihm pour ajouter le nom, lister les noms, afficher 1 nom , et supprimer le nom

la classe IHMPersonne donne l'apparence de l'application avec des methodes d'affichage et appelle des methodes de la classe personne.

la classe ApplicationPersonne lance l'apllication ( le main)

voici leur code :

classe personne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
public class Personne {
 
	/**
         * @param args
         */
	private String nom;//variable prive declaré en format chaine 
 
	/*
	 * contructeur de la classe personne
	 * definit, le nom=nom
	 */
	public Personne(String nom){
		this.nom=nom;
	}
	/*
	 * fonction getNom qui return le nom de la personne
	 */
	public String getNom(){
		return nom;
	}
	/*
	 * procedure affichePersonne qui affiche le nom,prenom,age
	 */
	public void affichepersonne(){
		System.out.println(" Nom : "+getNom());
	}
}

classe Presentation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import java.io.Serializable;//pour la serialisation
//le but de ce programme est enregistrer un nom, de faire une hastable et de l'enregistrer dans un fichier
import java.util.Enumeration;
import java.util.Hashtable;
public class Presentation implements Serializable{
 
	//Hashtable pour stocker les personnes
	static Hashtable <String,Personne> tabPersonne;
	static private final long serialVersionUID = 6L;//pour la serialisation
 
	public Presentation (){
	tabPersonne = new Hashtable<String,Personne>();
	IHMPresentation .afficherMenu();
	}
 
	/**Methode pour ajouter une personne à la liste
         * @param ident
         * @param pers
         * @return
         */
	public static boolean ajouterPersonne(String ident,Personne pers){
		tabPersonne.put(ident,pers);
		return true;
	}
 
	public static boolean supprimerPersonne(String ident) 
	{	
		if (tabPersonne.containsKey(ident))
		{
			tabPersonne.remove(ident);
			return true;
		}
		else
			return false;
	}
	/** Methode qui renvoie une personne en fonction de son ident
         * @param ident
         * @return personne de l'identifiant
         */
	public static Personne getPersonne (String ident){
		if (indentPersonneDisponible(ident)) 
			return null;
		else
			return tabPersonne.get(ident);
	}
	/** Méthode listant toutes les personnes
         */
	public static void afficherPersonne(){
		System.out.println("La liste contient :"+tabPersonne.size()+" personne(s)");
		System.out.println("———————————————\n\n");
		Enumeration enumIdentPersonne = tabPersonne.keys();
		String cle;
		Personne personneLu =null;
		while(enumIdentPersonne.hasMoreElements())
		{
			cle=(String)enumIdentPersonne.nextElement();
 
			System.out.println("Clé : "+cle);
			System.out.println("—————————————");
			personneLu=tabPersonne.get(cle);
			personneLu.affichepersonne();		
			System.out.println();
		}
	}
	/** Methode qui vérifie si l'identifiant n'est pas déjà utilisé
         * @param ident
         * @return disponibilité de l'ident
         */
	public static boolean indentPersonneDisponible(String ident){
		if (ident.equals("0"))return true;
		else return !tabPersonne.containsKey(ident);
	}
 
}

classe IHMPresentation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
import java.io.FileInputStream;
import java.io.ObjectInputStream;//pour la deserialisation
import java.io.FileOutputStream;//pour la serialisation
import java.io.IOException;//pour la serialisation et deserialisation
import java.io.ObjectOutputStream;//pour la serialisation
import java.util.InputMismatchException;
import java.util.Scanner;
public class IHMPresentation {
 
//	 Déclaration des variables 
	static String identPersonne;
	static Scanner clavier =new Scanner(System.in);
	static String nomPersonne=null;
	static Personne personne=null;
	static String reponse=null ;
 
	/** Methode affichant le Menu principal
         * 
         */
	public static void afficherMenu(){
		String reponse;
		do {
			do {
 
				effacerEcran();
 
				System.out.println("         +——--------------------------------------------—+");
				System.out.println("         *                                                      *");
				System.out.println("         *                  GESTION FICHE                       *");
				System.out.println("         *                  ------------------                  *");
				System.out.println("         *                                                      *");
				System.out.println("         *             1)   Ajouter le nom                      *");
				System.out.println("         *                                                      *");
				System.out.println("         *             2)   Lister le(s) nom (s)                *");
				System.out.println("         *                                                      *");
				System.out.println("         *             3)   Afficher le(s) nom (s)              *");
				System.out.println("         *                                                      *");
				System.out.println("         *             4)   Supprimer un nom                    *");
				System.out.println("         *                                                      *");
				System.out.println("         *                                                      *");
				System.out.println("         *                                                      *");
				System.out.println("         *             0)   QUITTER APPLICATION                 *");
				System.out.println("         *                                                      *");
				System.out.println("         +——————————————————————————————————————————————————————+");
				System.out.println("\n");
				System.out.print("Choix :");
				reponse=clavier.next();
 
			// Vérification de la conformité du choix saisi
			}while (!(reponse.equals("0") || reponse.equals("1") || reponse.equals("2") || reponse.equals("3") || reponse.equals("4")));
 
			// Gestion des choix du menu
			if (reponse.equals("1")) 
			{
				effacerEcran();
					try {
					/*
					 * ici je mets Presentation.ajouterPersonne(getIdentPersonne(), saisirPersonne());
					 * directment dans le try de la serialistion qui recupere la variable nomPersonne
					 * de la methode saisirPersonne()qui sera serialisé dans le fichier nom.serial
					 * ce qui donne :
					 *  Veuillez donner un identifiant à la personne saisie:
					 *  1 (identPersonne de methode getIdentPersonne())
					 *	Quel est le nom de la personne ?
					 *  dupont(nomPersonne de methode saisirPersonne())
					 *  creation de : dupont
					 *  dupont a ete serialise
					 */ 
					Presentation.ajouterPersonne(getIdentPersonne(), saisirPersonne());;
					System.out.println("creation de : " +nomPersonne);
 
					// ouverture d'un flux de sortie vers le fichier "personne.serial"
					FileOutputStream fos = new FileOutputStream("nom.serial");
 
					// création d'un "flux objet" avec le flux fichier
					ObjectOutputStream oos= new ObjectOutputStream(fos);
					try {
						// sérialisation : écriture de l'objet dans le flux de sortie
						oos.writeObject(nomPersonne); 
						// on vide le tampon
						oos.flush();
						//System.out.println(p + " a ete serialise");
						System.out.println(nomPersonne+ " a ete serialise");
					} finally {
						//fermeture des flux
						try {
							oos.close();
						} finally {
							fos.close();
						}
					}
				} catch(IOException ioe) {
					ioe.printStackTrace();
				}
				poursuivreConsult();
			}
			if (reponse.equals("2")) 
			{	effacerEcran();
				Presentation.afficherPersonne();
				/*ici pour la deserialisation
				 * ici je mets Presentation.afficherPersonne();
				 * avant le try de la deserialistion je creee une variable p type string que j'initialise
				 * je declare la variable p = IHMPresentation.nomPersonne qui recupere le nom passé
				 * en serialisation dans nomPersonne
				 * ce qui donne :
				 * La liste contient :0 personne(s)(bug a voir dans la methode afficherPersonne)
				 * ——————————---------------------
				 * dupont a ete deserialise
				 */ 
				String p = null;
				//Personne p = null;
				IHMPresentation.nomPersonne = p;
					try {
					// ouverture d'un flux d'entrée depuis le fichier "nom.serial"
					FileInputStream fis = new FileInputStream("nom.serial");
					// création d'un "flux objet" avec le flux fichier
					ObjectInputStream ois= new ObjectInputStream(fis);
					try {	
						// désérialisation : lecture de l'objet depuis le flux d'entrée
						//p = (Personne) ois.readObject();
						p=(String) ois.readObject();
					} finally {
						// on ferme les flux
						try {
							ois.close();
						} finally {
							fis.close();
						}
					}
				} catch(IOException ioe) {
					ioe.printStackTrace();
				} catch(ClassNotFoundException cnfe) {
					cnfe.printStackTrace();
				}
				if(p != null) {
					System.out.println(p + " a ete deserialise");
				}
				poursuivreConsult();
			}
			if (reponse.equals("3")) 
			{
				identPersonne=afficherGetPersonne();	
				if (!identPersonne.equals("0")) {Presentation.getPersonne(identPersonne).affichepersonne();
				poursuivreConsult();}
 
			}
			if (reponse.equals("4")) 
			{
				identPersonne=afficherGetPersonne();	
				if (!identPersonne.equals("0")) 
					if (Presentation.supprimerPersonne(identPersonne))
						System.out.println("Personne : "+identPersonne+" Supprimée");
					else
						System.out.println("Erreur dans la suppression Parcelle : "+identPersonne+" Non supprimée");	
				poursuivreConsult();			
			}
 
		}while(!reponse.equals("0"));
		System.out.println("Bonne journée !");
	}
/** Methode qui à partir du type de personne l'interface graphique adaptée */
 
	public static Personne saisirPersonne(){
		System.out.println("Quel est le nom de la personne ?");
		System.out.println("————————————————————————————————");	
		nomPersonne=clavier.nextLine();
		System.out.println();
		return new Personne(nomPersonne);
		}
 
	/**
         * Methode pour effacer l'écran de la console
         */
	public static void  effacerEcran(){			
		try {
			if(System.getProperty("os.name" ).startsWith("Windows" ))
				Runtime.getRuntime().exec("cls" );
			else
				Runtime.getRuntime().exec("clear" );
		} catch(Exception excpt) {
			for(int i=0;i<100;i++)
				System.out.println();
		}
	}
 
		/**
                 * Methode pour demander l'identiant de la personne pour la Hashtable
                 * @return identifiant saisi
                 */
		static String getIdentPersonne(){
			String identPersonne=null;
			do
			{
				effacerEcran();
				System.out.println("\nVeuillez donner un identifiant à la personne saisie:");
				System.out.println("——————————————————————————————————————————————————————");
				identPersonne=clavier.nextLine();
			}while(identPersonne.equals("") ||				
					!Presentation.indentPersonneDisponible(identPersonne));
			return identPersonne;
		}
		/**
                 * Methode d'arret de défilement pour la visualisation des resultats
                 */
		static private void poursuivreConsult(){
			System.out.print ("\n\n Appuyez sur une touche et validez pour pousuivre la consultation");
			reponse=clavier.next();
			reponse="n";
		}
 
		/**
                 * Methode pour demander l'identiant de la personne pour recherche dans la Hashtable
                 * @return identifiant saisi ou 0 si rien
                 */
		static String afficherGetPersonne(){
			effacerEcran();
			String identPersonne;
			Scanner clavier = new Scanner(System.in);
			do
			{	
				System.out.println("Veuillez donner l'identifiant de la personne ou 0 pour sortir:");
				System.out.println("——————————————————————————————————————————————————————————————");
				identPersonne=clavier.nextLine();
				if (Presentation.indentPersonneDisponible(identPersonne)) System.out.println("\nIdentifiant de personne inconnue");
			}while(!identPersonne.equals("0") && Presentation.indentPersonneDisponible(identPersonne));
			return identPersonne;
		}
 
		/**
                 * Méthode qui demande et vérifie la donnée saisie
                 */
		static double saisiDoubleVérifie(){
			boolean valide;
			double valeur=0;
			do{
				valide=true;
 
				try{
					valeur=clavier.nextDouble();
				}catch(InputMismatchException	e)
				{
					valide=false; 
					System.err.println("Erreur de saisie");			
				}
				if (!valide && valeur<=0)
				{
					System.out.println("\nVous avez saisie une valeur erronnée, veuillez resaisir une valeur :");
					System.out.println("——————————————————————————————————————————————————————————————————————");
					clavier.next();
				}
			}while(!valide && valeur<=0);
 
			return valeur;
		}
}

classe ApplicationPersonne

Code:

1
2
3
4
5
6
7
8
9
10
11
public class ApplicationPersonne {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		// TODO Raccord de méthode auto-généré
		//programme principal appelant la presentation Personne
		new Presentation();
		}
}

donc je lance la classe MAin = ApplicationPersonne qui creee une new Presentation()(classe presentation); qui lance IHMPresentation .afficherMenu();

et je mets ma serialisation dans la gestion des menu de la classe IHMPresention

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// Gestion des choix du menu
			if (reponse.equals("1")) 
			{
				effacerEcran();
					try {
					/*
					 * ici je mets Presentation.ajouterPersonne(getIdentPersonne(), saisirPersonne());
					 * directment dans le try de la serialistion qui recupere la variable nomPersonne
					 * de la methode saisirPersonne()qui sera serialisé dans le fichier nom.serial
					 * ce qui donne :
					 *  Veuillez donner un identifiant à la personne saisie:
					 *  1 (identPersonne de methode getIdentPersonne())
					 *	Quel est le nom de la personne ?
					 *  dupont(nomPersonne de methode saisirPersonne())
					 *  creation de : dupont
					 *  dupont a ete serialise
					 */ 
					Presentation.ajouterPersonne(getIdentPersonne(), saisirPersonne());;
					System.out.println("creation de : " +nomPersonne);

					// ouverture d'un flux de sortie vers le fichier "personne.serial"
					FileOutputStream fos = new FileOutputStream("nom.serial");

					// création d'un "flux objet" avec le flux fichier
					ObjectOutputStream oos= new ObjectOutputStream(fos);
					try {
						// sérialisation : écriture de l'objet dans le flux de sortie
						oos.writeObject(nomPersonne); 
						// on vide le tampon
						oos.flush();
						//System.out.println(p + " a ete serialise");
						System.out.println(nomPersonne+ " a ete serialise");
					} finally {
						//fermeture des flux
						try {
							oos.close();
						} finally {
							fos.close();
						}
					}
				} catch(IOException ioe) {
					ioe.printStackTrace();
				}				poursuivreConsult();
			}

et cela marche bien car quand je creee un utiliasteur dans 1) ajouter un nom j'ai le message :

creation de dupont
dupont a été serialiser

et meme la deserialisation marche...

mais quand je ferme eclipse quand je clique sur 2) Lister le(s) nom (s)

il me dit que j'ai 0 personne dans la liste

donc pourquoi la serialisation marche dans mon apllication le fichier se creee et deserialise et quand je ferme eclipse rien. ??????

15/12/2009, 14h52
hibour

Il faut que le champ que tu veux sérialiser soit ni static ni transient

Code:

static Hashtable <String,Personne> tabPersonne; //Enleve le static

A++
17/12/2009, 14h01
vegange

:P merci a toi mais ta reponse ne m'apporte pas la solution.

je pense que je me suis tromper dans une methode. car la reponse " il vous reste 0 personnes et une methode appeller en fonction de la hastable et la serialisation et faite avec une variable passé pas une methode qui appelle le nom de la personne donc je pense que je bug par là. je vais me pencher sur mes methodes.

mais j'ai quand meme essayé en enlevant static à la hastable et çà ne marche pas. de plus mes methodes et variables sont déclarées static.

je donnerais la solution quand j'aurais trouvé, mais je pense alléger mon ihm

merci :ccool:

ps: mon but est de creer pour apprendre :mouarf:
17/12/2009, 16h57
hibour

Le mécanisme de la sérialisation est fait de tel sorte qu'il ne sérialise pas les champs static c'est pour ça j'ai dit que c'était la cause du problème car je pensais que tu sérialisais l'instance IHM..
J'ai remarqué que ta classe Personne n'est pas Serializable tu devrai avoir une NotSerializableException quand tu essai de faire la sérialisation.
Pour ton application lors du d"marrage du main tu doit:
1- Chercher ton fichier xxx.ser s'il se trouve tu charge ta Map
2-Sinon tu crée une nouvelle Map vide et là tu démarre ton application.
A++