Discussion :

[wassim_boy]

bonjour,

voila je suis entrain de développer une petite application et, grosso-modo, j'ai en entrée un fichier (>300MO), je fais des traitements sur le fichier puis en sortie j'ai un nouveau fichier modifier.

mon problème est le temps d'exécution qui est considérablement grand (5h pour un fichier de 300MO). est ce que quelqu'un peut m'aider sur le sujet?

je suis entrain de chercher sur le net mais le temps presse et je serai très reconnaissant si l'un de vous pourra me faire gagner du temps

merci

NB : je suis nouveau sur le forum et je vous demande de m'excuser si jamais j'ai fais une erreur ou que j'explique mal mon problème.

[oneagaindoguys]

Bonjour,

De quel type de fichier s'agit-il ? Quels sont les traitements à faire dessus ?

[wassim_boy]

le type de fichier n'est pas donné (texte, image, video, ...)

au fait je récupère les octets du fichier en entrée un par un et je modifie chaque octet, je l'écris puis je passe au suivant

je le traite octet par octet car si je veux récupérer tout le fichier dans un tableau j'aurai l'erreur outofmemory. je peux augmenter la taille de la JVM mais le problème c'est que ça marchera que sur ma machine et pas sur une autre.

merci pour votre réponse et j'espère que j'étais clair

[le y@m's]

Plutôt que de lire un octet après l'autre tu peux utiliser un buffer.

Code :

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

1
2
3
4
5
6
InputStream input = ...;
byte[] buffer = new byte[4096];
int nbRead = 0;
while((nbRead = input.read(buffer)) > 0) {
    // traiter les octets de 0 à nbRead dans le buffer
}

[wassim_boy]

merci pour votre réponse le y@m's

j'ai juste une petite question le tableau buffer va contenir tout le fichier?

car j'ai essayé de mettre tout le fichier dans un tableau de byte mais étant donné que le fichier est grand je me retrouve avec une erreur outofmemory.

voici un extrait de mon code, espérant que cela vous aidera à trouver le problème :

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
 
...
try
        {  //Ouverture des flux e/s
            File f = new File(this.source);
            FileInputStream in = new FileInputStream(f);
            FileOutputStream os = new FileOutputStream(new File(dest));
            while(in.available()!=0)
            {
             //Recupere le premier octet du fichier
                next = in.read();
                b_fichier = (byte) next;
                next = 0;
              //traitement sur la variable b_fichier (opération arithmétique dans une boucle for)
                ....
                ....
              //Ecriture de l'octet dans le fichier de sortie
                os.write(b_fichier);
            } 
            //Fermeture des flux
            in.close();
            os.close();
        } 
        catch (Exception e){
            System.out.println(e.toString());
        }

voila si vous avez d'autre questions je suis la. merci

[adiGuba]

Salut,


Non le buffer va stocker une petite partie du fichier. Pour un "petit" coût en mémoire (en général on utilise un buffer de 8192 octet) cela diminue énormément le nombre d'accès IO...


Quelques remarques :

• Il suffit d'utiliser un BufferedInputStream/BufferedOutputStream pour utiliser un buffer de manière totalement transparente (sans avoir rien à gérer donc).
• Il faut utiliser les try/finally pour libérer proprement les ressources (ou le try-with-resources de Java 7)
• N'utilises pas available() ! Non seulement son résultat n'est pas garantie mais cela implique également un accès supplémentaire au système de fichier. Il est préférable de lire le fichier jusqu'à recevoir un -1 en retour de read()
• Ta gestion des exceptions est assez limité... Non ?

Bref ca devrait donner quelque chose comme cela :

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
	try { // Ouverture des flux e/s
		File f = new File(this.source);
		InputStream in = new BufferedInputStream(new FileInputStream(f));
		try {
			OutputStream os = new BufferedOutputStream(new FileOutputStream(new File(dest)));
			try {
 
				while (true) {
					int r = in.read();
					if (r<0) break; // Fin du fichier
 
					byte b = (byte) r;
					// traitement sur la variable b_fichier (opération arithmétique dans une boucle for)
					// ...
					// Ecriture de l'octet dans le fichier de sortie
					os.write(b);
				}
			} finally {
				os.close();
			}
		} finally {
			in.close();
		}
	} catch (Exception e) {
		// N'y aurait-il pas mieux à faire ????
		System.out.println(e.toString());
	}

Il faudrait également savoir ce que tu fais dans ta boucle for, car il est également possible que ce soit la source de ton problème : pour un fichier de 300Mo tu va exécuter cette boucle 300 000 000 fois...



a++