Performance en lecture/ecriture d'une collection d'objet serializable ?
Bonjour tout le monde,
Voilà je m’initie à la programmation (Java) depuis peu et je suis confronté à un problème que je ne parviens pas à résoudre et je ne trouve pas d’infos sur le net.
Mon cahier des charges est le suivant :
J’ai un objetB qui est une liste d’ objetA serializable.
Je dois pouvoir ajouter de nouveau objetA à mon objetB sur demande et ce dernier doit conserver toutes les entrées précédentes.
Je dois aussi pouvoir récupérer tous les objetA ou un en particulier
Voici, en gros, comment se construit mon objetB :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| //Code simplifié à l'extreme
public class ObjetB {
ArrayList<ObjetA> listObjetA = new ArrayList<ObjetA>() ;
public ObjetB(){
File fichier = new File(path);
if(fichier.length() > 0) {
ObjectInputStream in = new ObjectInputStream(
New BufferedInputStream(
new FileInputStream(fichier)));
listObjetA = (ArrayList<listObjetA>)in.readObject();
in.close();
}
}
} |
Pour ajouter un objetA pas de soucis :
Code:
1
2
3
4
5
| public void addObjetA(ObjetA objetA){
listObjetA.add(objetA) ;
serialize() ; //Ici je serialize mon ArrayList
} |
Et par exemple pour obtenir la desciption de mes ObjetA:
Code:
1
2
3
4
5
6
| public String toString(){
for(ObjetA obj : listeObjetA)
str += obj.toString() ;
return str ;
} |
En fait c’est là que mon problème se pose, j’ai fait des tests, et appeler la méthode toString() est relativement rapide tant que ma listObjetA ne contient que quelques dizaines d’ ObjetA mais, en ajoutant 2000 objetA à mon ObjetB, l’appel de cette méthode prend 10 bonnes secondes. C’est long, trop long !
J’ai donc tenté de coder mes objets un peu différemment en serializant non pas une ArrayList mais directement mes ObjetA.
Désormais lorsque j’appelle la méthode toString() de mes 2000 ObjetA :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| //Code simplifié à l'extreme
public String toString(){
File fichier = new File(path);
if(fichier.length() > 0) {
ObjectInputStream in = new ObjectInputStream(
New BufferedInputStream(
new FileInputStream(fichier)));
while(true)
str += in.readObject().toString();
in.close() ;
}
return str;
} |
De cette manière je lis le fichier en 3,5 secondes(c’est quand même long non ?) mais par contre à chaque fois que je réouvre un flux vers mon fichier pour ajouter un ObjetA, celui-ci est écrasé et ne contient que la dernière entrée.
Je pourrais mettre tous mes ObjetA dans une ArrayList à l’ouverture du flux, ajouter l’objetA à insérer et repasser par une boucle pour serializer mes ObjetA.
Mais dans ce cas le gain de performance à la lecture est perdu lors de l’écriture…
Bref je ne sais pas comment faire.
Existe-il un moyen pour ajouter un ObjetA à mon fichier sans que celui-ci soit écrasé ?
Mes connaissances en Java(ainsi qu’en programmation) étant limitées je sollicite vos conseils et votre expérience afin de m’orienter sur la bonne voie(qui est d’ailleurs peut-être à l’opposé de la méthode que j’utilise)
Merci.
