Discussion :

[xarius]

Bonjour,

Le contexte :

En fait je veux ouvrir un seul flux de données et pouvoir le réutiliser plusieurs fois.

Ouverture du flux

fonction lecture 1 -> (lit un bloc de ligne)
fonction lecture 2 -> (lit une ligne)
fonction lecture 3 -> (lit une ligne)

Fermeture du flux.

J'ai pensé à la sérialisation mais c'est pareil ça ne marche qu'une seule fois.(voir ci-dessous)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
public class MainBuffered {
 
    protected static TestBufferedReader obj1 = null;
 
    protected static TestBufferedReader obj2 = null;
 
    public static void main(String args[]) {
 
        try {
            // Sauvegarde de l'objet
            sauvergardeObjet();
 
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        try {
            lectureObjet().testerlecture();
        } catch (IOException e1) {
            e1.printStackTrace();
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
 
 
 
        try {
            lectureObjet().testerlecture();
        } catch (IOException e1) {
            e1.printStackTrace();
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
    }
 
    protected static void sauvergardeObjet() throws ClassNotFoundException,
            IOException {
        obj1 = new TestBufferedReader(
                "C:/eclipse/workspace/testDiverses/source.txt");
 
        //obj1.testerlecture();
 
        ObjectOutputStream out;
        out = new ObjectOutputStream(new FileOutputStream("buffered.out"));
        out.writeObject(obj1);
        out.flush();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                "buffered.out"));
 
        out.close();
 
        System.out.println("Sauvegarde de l'objet 1 OK");
    }
 
    protected static TestBufferedReader lectureObjet() throws IOException,
            ClassNotFoundException {
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                "buffered.out"));
        TestBufferedReader obj2 = (TestBufferedReader) in.readObject();
        return obj2;
 
    }
}

Auriez vous idées pour y arriver ?

Cordialement,

xarius

[iohack]

Je comprends pas trop ton problème, si tu veux sauvegarder/charger 3 trois objets à la suite dans un fichier sans ouvrir - lire/ecrire - fermer à chaque fois, rien ne t'empeche de faire trois appels successifs aux méthodes writeObject/readObject.
Sinon, je pense que c'est l'architecture de ta classe qui n'est pas correct ( c'est pas très joli tous ces trucs "static" ! ).
Je te propose donc la méthode suivantes ( il y en a d'autres ) :
- ouvrir les deux flux dans le constructeur de ta classe
- créer une méthode lire qui te retourne le resultat de readObject.
- créer une méthode écrire qui prend en paramètre un objet passé à la méthode writeObject.
- créer une méthode close permettant de fermer les deux correctement.

Avec ce modèle, les flux restent ouverts et opérationnels pendant toute la durée d'existance de ton instance.

[xarius]

Bonjour,

Voila en code ce que je voudrai faire. Appeler plusieurs fois lire pour pouvoir relire le fichier en entier à chaque fois.

Mais ici dans le code il le fait q'une seule fois.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
package divers;
 
import java.io.BufferedReader;
import java.io.IOException;
 
spublic class GestionFichier {
 
	public static void main(String[] args) {
 
		BufferedReader reader = null;
 
		LireFichier lecture = new LireFichier();
		reader = lecture.ouvrirFlux();
 
		lireFichier(reader);
 
		lireFichier(reader);
 
		lireFichier(reader);
 
		// fermeture du flux
		lecture.fermerFlux(reader);
	}
 
	public static void lireFichier(BufferedReader reader) {
		String ligne = null;
 
		try {
			while ((ligne = reader.readLine()) != null) {
				System.out.println(ligne);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
package divers;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
 
public class LireFichier {
 
	public BufferedReader ouvrirFlux() {
		File cheminFichierData = null;
		FileReader fluxLectureTexte = null;
		BufferedReader buffer = null;
 
		try {
			cheminFichierData = new File("source.txt");
 
			fluxLectureTexte = new FileReader(cheminFichierData);
			buffer = new BufferedReader(fluxLectureTexte);
 
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
 
		return buffer;
	}
 
	public void fermerFlux(BufferedReader buffer) {
 
		try {
			buffer.close();
 
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
 
}

Merci.

xarius