Discussion :

[tom78]

Bonjour à tous,

je suis débutant en java et je me pose une question. En fait, je dois un ecrire un ensemble de lignes (paquet) dans un fichier à un instant donnée.

Cad que je fais plusieurs write("____") et j'aimerais qu'il soit vraiment ecris dans le fichier à un moment donné et SEULEMENT à ce moment.

Donc, qd j'ai write un certains nombre de ligne (cad un paquet de 1000 par exemple) je fais un flush pour qu'il soit ecris dans le fichier.
Je voulais savoir si c'est vraimant le flush qui mets mes lignes dans le fichier et si c'est la bonne solution ??

j'espere avoir été assez clair,
merci d'avance.

[adiGuba]

Salut,


Le flush() permet de forcer l'écriture des données, mais rien ne dit que ce n'est pas déjà fait.

En fait dans le cas des fichiers, les données sont stocker dans un buffer et ne sont réellement écrites dans le fichier que lorsque le buffer est plein ou qu'on force cela par un flush.

Donc cela ne correspond pas vraiment à ce que tu attends, puisque lorsque tu appelles flush() il se peut très bien que les données soient déjà écrites...



Pour faire ce que tu veux il faudrait utiliser un filtre qui stockerait tout en mémoire et n'écrirait tout qu'au moment du flush(), ce qui donnerait :

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
public class OnDemandWriter extends FilterWriter {
 
	private final StringBuilder builder = new StringBuilder();
 
	public OnDemandWriter(Writer writer) {
		super(writer);
	}
 
	/*
	 * On redéfini les méthodes write() pour écrire dans un buffer
	 * plutôt que dans le writer associé
	 */
 
	@Override
	public void write(char[] cbuf, int off, int len) throws IOException {
		synchronized(this.lock) {
			this.builder.append(cbuf, off, len);
		}
	}
 
	@Override
	public void write(int c) throws IOException {
		synchronized(this.lock) {
			this.builder.append((char)c);
		}
	}
 
	@Override
	public void write(String str, int off, int len) throws IOException {
		synchronized(this.lock) {
			this.builder.append(str, off, len);
		}
	}
 
	/*
	 * On redéfini flush() pour qu'il écrive les données et force le flush()
	 */
 
	@Override
	public void flush() throws IOException {
		synchronized(this.lock) {
			super.write(this.builder.toString());
			this.builder.setLength(0);
			super.flush();
		}
	}
 
	/*
	 * On redéfini close() pour forcer un flush avant la fin
	 * (et ainsi éviter d'écrire des données)
	 */
 
	@Override
	public void close() throws IOException {
		this.flush();
		super.close();
	}
}

Attention le buffer conserve toujours sa taille la plus grande. Si on a parfois de très grande quantité de données à écrire il faudrait peut-être utiliser un trimToSize() sur le buffer...


a++

[tom78]

ok merci pour les précisions !!!!

du coup, si j'ai bien compris , t'en que je fais pas le flush() , ca n'écrira pas physiquement dans le fichier !?

je write avec la fonction ou se trouve en parametre le String car c'est ce don j'ai besoin.
pour la fonction this.builder.append(str, off, len);, est ce que tu peux me dire ce que représente off et len ???

merci d'avance