Sauvegarder des variables dans un fichier

Version imprimable

Bonjour à tous !
Je suis en train de créer un programme qui sera un jeu. Ce dernier nécessitera plusieurs sessions de jeu pour en arriver à bout.
C'est pourquoi j'ai besoin d'une fonction de sauvegarde.

Le jeu étant plutôt simple dans sa conception, je n'aurais que 4 variables (3 int et 1 String) à sauvegarder pour pouvoir relancer le joueur où il s'est arrêté.

Quelle méthode est la mieux adaptée à votre avis ? Ecrire les variables dans un fichier ou serialiser un objet dans un fichier ?

Pour le 1er cas, il faudra écrire une variable par ligne non ?! Comment on fait pour changer de ligne ?
Pour charger le fichier il faut réussir à lire ligne par ligne pour avoir ligne1 = variable1, ligne2 = variable2, etc... Mais ça non plus je ne sais pas comment le faire.

Pour le 2e cas, je crois avoir réussi à sérialiser les variables que j'ai intégrées à un objet :
La classe qui contient mes variables :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Variables implements Serializable { public static String prenom = ""; // Le prénom du joueur public static int genre; // Le genre du joueur public static int situation; // L'étape sur laquelle le joueur s'est arrêté public static int days = 0; // Le nombre d'étapes franchies public Variables(String prenom, int genre, int situation, int days) { this.prenom = prenom; this.genre = genre; this.situation = situation; this.days = days; } }
L'actionListener du bouton "sauvegarder" :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 sauvegarder.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JFileChooser sauver = new JFileChooser(); sauver.setDialogTitle("Sauvegarder"); sauver.showSaveDialog(null); String nomFichier = sauver.getSelectedFile(); ObjectOutputStream oos; try { oos = new ObjectOutputStream( new BufferedOutputStream( new FileOutputStream( new File(nomFichier)))); oos.writeObject(new base.Variables(base.Variables.prenom, base.Variables.genre, base.Variables.situation, base.Variables.days)); oos.close(); } catch (IOException f) { f.printStackTrace(); } } });
Donc là je pense que j'ai sérialisé mon objet "Variables".
Maintenant ce dont j'ai besoin (sauf erreur de ma part) c'est désérialiser mon objet et de réattribuer ses variables aux variables déclarées static de ma classe Variables.
J'ai fait ça dans l'actionListener du bouton "charger" :
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 loadGame.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JFileChooser ouvrir = new JFileChooser(); ouvrir.setDialogTitle("Charger un fichier de sauvegarde"); ouvrir.showOpenDialog(null); String nomFichier = String.valueOf(ouvrir.getSelectedFile()); ObjectInputStream ois; try { ois = new ObjectInputStream( new BufferedInputStream( new FileInputStream( new File(nomFichier)))); Object obj = ois.readObject(); Variables newVariables = (Variables) obj; ois.close(); base.Variables.prenom = newVariables.prenom; base.Variables.genre = newVariables.genre; base.Variables.situation = newVariables.situation; base.Variables.days = newVariables.days; } catch (IOException g) { g.printStackTrace(); } catch (ClassNotFoundException g) { g.printStackTrace(); } System.out.println(base.Variables.prenom); System.out.println(base.Variables.genre); System.out.println(base.Variables.situation); System.out.println(base.Variables.days); }});
Mais aux vues de ce qui sort dans la console, ça ne fonctionne pas...

Merci infiniment pour votre aide ! ;)

09/11/2019, 20h04
joel.drigo
Salut,

La sérialisation (sous entendu par Serializable) c'est plutôt adapté pour faire du transfert, par exemple sur le réseau. Le problème de la sérialisation vers un fichier, c'est la version de la classe Dès qu'on fait un changement dans la classe, le fichier n'est plus chargeable sans faire quelque chose de spécial pour le convertir.

Pour sauvegarder des données :
1. soit tu veux pouvoir éditer le fichier pour le modifier et un format texte, structuré (properties, xml, json, yaml, csv, etc), est le plus adapté amha
2. soit sauvegarde dans un fichier binaire (avec DataOuputStream et DataInputStream pour lire, pour des données simples (primitifs et String) et ObjectOuputStream et ObjectInputStream pour lire, pour des objets, comme un bean).
Citation:

Envoyé par Vahia

Pour le 1er cas, il faudra écrire une variable par ligne non ?! Comment on fait pour changer de ligne ?

Avec un fichier texte structuré, il faut utiliser un sérialiseur et un parseur adapté. Avec un fichier binaire, pas besoin de se préoccuper des lignes. Avec DataOutputStream, on écrit les données dans un ordre précis, et avec DataInputStream, on les lit dans le même ordre. Il vaut mieux s'arranger pour avoir une information de version, juste au cas où les types et l'ordre pourrait changer.

Pour charger le fichier il faut réussir à lire ligne par ligne pour avoir ligne1 = variable1, ligne2 = variable2, etc... Mais ça non plus je ne sais pas comment le faire.

Citation:

Envoyé par Vahia

Mais aux vues de ce qui sort dans la console, ça ne fonctionne pas...

C'est parce que les attributs de Variables sont static. On sérialise et désérialise des objets (des instances de classe), c'est à dire leurs attributs, leurs variables d'instance.
09/11/2019, 20h13
Vahia

Merci joel.drigo !

Je n'ai pas besoin d'avoir un fichier structuré. Sauvegarder dans un fichier binaire conviendrait parfaitement.
Tu aurais un exemple pour écrire et lire dans ce type de fichier ?

Exemple avec DataOutputStream/DataInputStream :

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
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class GameData {
 
	private final static String HEADER = "MGHA"; // permet de tester que le fichier est bien un fichier de data pour notre jeu
	private final static int VERSION = 1;
 
	private int dernierniveauatteint;
	private int score;
	private int nombredevierestante;
	private String nomjoueur;
 
	private final List<Integer> cinqmeilleurscores = new ArrayList<>();
 
	public void reset() {
		dernierniveauatteint=0;
		score=0;
		nombredevierestante=0;
		nomjoueur=null;
		cinqmeilleurscores.clear();
	}
 
	public int getDernierNiveauAtteint() {
		return dernierniveauatteint;
	}
 
	public void setDernierNiveauAtteint(int dernierniveauatteint) {
		this.dernierniveauatteint = dernierniveauatteint;
	}
 
	public int getScore() {
		return score;
	}
 
	public void setScore(int score) {
		this.score = score;
	}
 
	public int getNombreDeVieRestante() {
		return nombredevierestante;
	}
 
	public void setNombreDeVieRestante(int nombredevierestante) {
		this.nombredevierestante = nombredevierestante;
	}
 
	public String getNomJoueur() {
		return nomjoueur;
	}
 
	public void setNomJoueur(String nomjoueur) {
		this.nomjoueur = nomjoueur;
	}
 
	public void ajouterNouveauScore(int...scores) {
		for(int score : scores) {
			this.cinqmeilleurscores.add(score);
		}
		Collections.sort(this.cinqmeilleurscores, Comparator.<Integer>naturalOrder().reversed());
		if ( this.cinqmeilleurscores.size()>5 ) {
			this.cinqmeilleurscores.subList(5, this.cinqmeilleurscores.size()).clear();
		}
	}
 
	public List<Integer> getMeilleurscores() {
		return Collections.unmodifiableList(cinqmeilleurscores);
	}
 
	public void saveToFile(String filepath) throws IOException {
		Path path = Paths.get(filepath);
		Files.createDirectories(path.getParent());
		try(DataOutputStream out = new DataOutputStream(Files.newOutputStream(path))) {
			writeHeader(out, HEADER);
			out.writeInt(VERSION);
			out.writeInt(dernierniveauatteint);
			out.writeInt(score);
			out.writeInt(nombredevierestante);
			out.writeUTF(nomjoueur);
			out.writeInt(cinqmeilleurscores.size());
			for(int meilleurscore : cinqmeilleurscores) {
				out.writeInt(meilleurscore);
			}
		}
	}
 
	private void writeHeader(DataOutputStream out, String header) throws IOException {
		out.write(header.getBytes());
	}
 
	public void loadFromFile(String filepath) throws IOException {
		try(DataInputStream in = new DataInputStream(Files.newInputStream(Paths.get(filepath)))) {
			checkHeader(in);
			int version = in.readInt();
			switch(version) {
			case 1:
				reset();
				loadVersion1(in);
				break;
			default:
				throw new IOException("Fichier non reconnu");
			}
		}
	}
 
	private void loadVersion1(DataInputStream in) throws IOException {
		dernierniveauatteint = in.readInt();
		score = in.readInt();
		nombredevierestante = in.readInt();
		nomjoueur = in.readUTF();
		int nbmeilleurscores = in.readInt();
		for(int i=0; i<nbmeilleurscores; i++) {
			cinqmeilleurscores.add(in.readInt());
		}
	}
 
	private void checkHeader(DataInputStream in) throws IOException {
		String header = new String(in.readNBytes(4));
		if ( !header.equals(HEADER) ) {
			throw new IOException("Fichier non reconnu");
		}
	}
 
	// exemple
	public static void main(String[] args) throws IOException {
 
		GameData data = new GameData();
 
		data.setNomJoueur("Suricate");
		data.setDernierNiveauAtteint(42);
		data.setScore(2080098);
		data.setNombreDeVieRestante(7);
		data.ajouterNouveauScore(2988282,129889,2992828,40098772,49827727,8288227);
 
		String path = System.getProperty("user.home") + "/mygamemachintruc/gamedata.bin";
 
		System.out.println("Emplacement fichier : " + Paths.get(path));
		data.saveToFile(path);
 
		data.reset();
 
		data.loadFromFile(path);
 
		System.out.println("Nom joueur : " + data.getNomJoueur());
		System.out.println("Dernier niveau atteint : " + data.getDernierNiveauAtteint());
		System.out.println("Score : " + data.getScore());
		System.out.println("Nombre de vie restante : " + data.getNombreDeVieRestante());
		System.out.println("Meilleurs scores :");
		int nscore=1;
		for(int score : data.getMeilleurscores()) {
			System.out.println(nscore++ + " : " + score);
		}
 
	}
 
}

14/11/2019, 15h40
Vahia

joel.drigo a encore frappé !
ça marche nickel, un grand merci !!! ;)