[Copie de Fichier] Quelle méthode est la plus rapide ?

**n@n¤u** · 04/05/2006, 09h42

Bonjour,
j'ai besoin de faire un copier coller de fichier en java.
Pour cela, j'ai trouvé deux exemples de code qui répondent à mon besoin.

Voici le premier :

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
import java.io.*;
 
public class JCopy{
  public static void main(String args[]){
    try {
      JCopy j = new JCopy();
      j.copyFile(new File(args[0]),new File(args[1]));
      }
    catch (Exception e) {
      e.printStackTrace();
      }
    }
 
  public void copyFile(File in, File out) throws Exception {
    FileInputStream fis  = new FileInputStream(in);
    FileOutputStream fos = new FileOutputStream(out);
    byte[] buf = new byte[1024];
    int i = 0;
    while((i=fis.read(buf))!=-1) {
      fos.write(buf, 0, i);
      }
    fis.close();
    fos.close();
    }
  }

Et le deuxiè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
import java.nio.channels.*;
import java.io.*;
 
public class JCopy2{
  public static void main(String args[]){
    try {
      JCopy2 j = new JCopy2();
      j.copyFile(new File(args[0]),new File(args[1]));
    }
    catch (Exception e) {
      e.printStackTrace();
    }
 }
 
  public void copyFile(File in, File out) throws Exception {
     FileChannel sourceChannel = new
          FileInputStream(in).getChannel();
     FileChannel destinationChannel = new
          FileOutputStream(out).getChannel();
     sourceChannel.transferTo(0, sourceChannel.size(), destinationChannel);
     // or
     //  destinationChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
     sourceChannel.close();
     destinationChannel.close();
     }
  }

Ma question est : comment déterminer le code le plus performant en ce qui concerne la vitesse ? Peut-on chronometrer le temps pour comparer les 2 bouts de code ?

Merci à vous

**iohack** · 04/05/2006, 09h46

Pour chronométrer, tu peux le faire avec : System.currentTimeMillis(), tu en met un au début, un à la fin du traitement et la différence des deux te donnera le nombre de millisecondes écoulée.

**afrikha** · 04/05/2006, 09h49

Le deuxième code est nettement plus rapide que le premier. Le package java.nio a justement été créer pour accroitre la performance.

Tu peux vérifier cela en faisant la différence entre la date de début et de fin dans les deux cas. Pour obtenir le temps courant en millisecondes:

Code :

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

1
2
 
System.currentTimeMillis();

P.S: un article est en préparation sur java.io, il sera disponible prochainement.

**adiGuba** · 04/05/2006, 09h58

Salut,

En effet dans la documentation de transferTo() on peut lire :

This method is potentially much more efficient than a simple loop that reads from this channel and writes to the target channel. Many operating systems can transfer bytes directly from the filesystem cache to the target channel without actually copying them.

Sinon je te conseille fortement d'utiliser des bloc try/finally pour bien fermer tes fichiers même en cas d'exception :

Code :

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

1
2
3
4
5
6
7
8
9
    public void copyFile(File in, File out) throws IOException {
        FileChannel sourceChannel = new FileInputStream(in).getChannel();
        try {
            FileChannel destinationChannel = new FileOutputStream(out).getChannel();
            try {
                sourceChannel.transferTo(0, sourceChannel.size(), destinationChannel);
            } finally { destinationChannel.close(); }
        } finally { sourceChannel.close(); }
    }

a++

**n@n¤u** · 04/05/2006, 10h00

J'ai déjà essayé en utilisant le code suivant, mais le problème est que 2 fois sur 3 le programme me signale que le traitement dure moins de 0 millisecondes.

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
public class Chrono {
    Calendar m_start = new GregorianCalendar();
 
    Calendar m_stop = new GregorianCalendar();
 
    public Chrono() {
    }
 
    // Lance le chronomètre
    public void start() {
        m_start.setTime(new Date());
    }
 
    // Arrète le chronomètre
    public void stop() {
        m_stop.setTime(new Date());
    }
 
    // Retourne le nombre de millisecondes séparant l'appel des méthode start()
    // et stop()
    public long getMilliSec() {
        return (m_stop.getTimeInMillis() - m_start.getTimeInMillis());
    }
 
    // Affiche le nombre de millisecondes séparant l'appel des méthode start()
    // et stop() sur la sortie standard
    public void printMilliSec() {
        if (getMilliSec() <= 0) {
            System.out.println("Vous n'avez pas arrété le chronomètre");
        } else {
            System.out.println("Temps d'exécution : " + getMilliSec() + " ms");
        }
    }
}

**afrikha** · 04/05/2006, 10h08

c'est normal, la précision n'est pas vraiment de l'ordre de la milliseconde, ça depend des os...la recopie est trop rapide pour se voir.Essaye avec des fichiers pus conséquents (de l'ordre de quelques Mo ), tu verras la différence...

[EDIT] tu n'as pas besoin de passer par la classe Calendar

Code :

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

1
2
3
4
 
long start=System.currenttimeMillis();
//copie du fichier
long durée=System.currentTimeMillis()-start;

[/EDIT]

**adiGuba** · 04/05/2006, 10h09

Envoyé par n@n¤u

J'ai déjà essayé en utilisant le code suivant, mais le problème est que 2 fois sur 3 le programme me signale que le traitement dure moins de 0 millisecondes.

C'est normal car si la valeur retourné est bien en milliseconde, la précision peut varier selon le système...

Ainsi sous Windows la précision est de l'ordre de 16ms environ... Donc si la méthode dure moins de 16ms il y a de forte chance que tu obtiennes 0 ou 16ms...

Pour obtenir des résultats utiles, il faut soit que ta méthode dure suffisamment longtemps (+ de 500ms, voire 1s), soit que tu appelles plusieurs fois la méthode dans une boucle afin d'obtenir un temps global plus long...

Enfin si tu es sous Java 5.0 tu peux utiliser System.nanoTime() qui peut avoir une meilleure précision...

a++

**n@n¤u** · 04/05/2006, 10h11

Envoyé par adiGuba

Salut,

En effet dans la documentation de transferTo() on peut lire :

Sinon je te conseille fortement d'utiliser des bloc try/finally pour bien fermer tes fichiers même en cas d'exception :

Code :

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

1
2
3
4
5
6
7
8
9
    public void copyFile(File in, File out) throws IOException {
        FileChannel sourceChannel = new FileInputStream(in).getChannel();
        try {
            FileChannel destinationChannel = new FileOutputStream(out).getChannel();
            try {
                sourceChannel.transferTo(0, sourceChannel.size(), destinationChannel);
            } finally { destinationChannel.close(); }
        } finally { sourceChannel.close(); }
    }

a++

Je ne comprends pas une chose : pourquoi ne pas faire un seul try/finally qui ferme les deux fichiers en même temps ?

**jowo** · 04/05/2006, 10h13

Bonjour,

Pas de besoin des classes Date et Calendar. Voici un version plus "légère".

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
 
public class Chrono {
    long m_start = 0L;
    long m_stop = 0L;
 
    public Chrono() {
    }
 
    // Lance le chronomètre
    public void start() {
        m_start = System.currentTimeMillis();
    }
 
    // Arrète le chronomètre
    public void stop() {
        m_stop = System.currentTimeMillis();
    }
 
    // Retourne le nombre de millisecondes séparant l'appel des méthode start()
    // et stop()
    public long getMilliSec() {
        return (m_stop - m_start);
    }
 
    // Affiche le nombre de millisecondes séparant l'appel des méthode start()
    // et stop() sur la sortie standard
    public void printMilliSec() {
        if (getMilliSec() <= 0) {
            System.out.println("Vous n'avez pas arrété le chronomètre");
        } else {
            System.out.println("Temps d'exécution : " + getMilliSec() + " ms");
        }
    }
}

Si tu travailles avec la version 5, tu peux utiliser la méthode nanoTime au lieu de currentTimeMillis.

Attention: l'exactitude milli ou nano seconde n'est pas garantie.

Sous Windows avec la méthode currentTimeMillis, tu as une exactitude d'environ 15ms.

**n@n¤u** · 04/05/2006, 10h21

J'ai fait les modifs dans le code du chrono et j'ai maintenant le temps en nano secondes. Mais j'ai un problème la deuxième méthode (celle qui est sensée être plus rapide) met beaucoup plus de temps que la 1ère.
Je ne comprends plus ?!

J'ai modifié la deuxième méthode :

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
public void copyFile2() {
 
        // Create channel on the source
        FileChannel srcChannel = null;
        FileChannel dstChannel = null;
 
        try {
            srcChannel = new FileInputStream("chemin_1").getChannel();
 
            // Create channel on the destination
            dstChannel = new FileOutputStream("chemin_2").getChannel();
 
            // Copy file contents from source to destination
            dstChannel.transferFrom(srcChannel, 0, srcChannel.size());
 
            // Close the channels
 
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                dstChannel.close();
                srcChannel.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

Je ne comprends toujours pas je dois faire 2 try imbriqués avec deux finally (comme me l'avait conseillé adiGuba)
Why ???

**adiGuba** · 04/05/2006, 10h42

Envoyé par n@n¤u

Mais j'ai un problème la deuxième méthode (celle qui est sensée être plus rapide) met beaucoup plus de temps que la 1ère.

C'est à dire ? qu'est-ce que tu veux dire par "beaucoup plus de temps" ??

Envoyé par n@n¤u

Je ne comprends toujours pas je dois faire 2 try imbriqués avec deux finally (comme me l'avait conseillé adiGuba)
Why ???

Parce que dans ton code, si tu as une exception lors de l'ouverture d'un des fichier, tu obtiendras par la suite un NullPointerException car il n'aura pas été initialisé...

Et puis cela permet de bien séparé les deux et de retrouver facilement l'ouverture et la fermeture du fichier...

Enfin si tu veux traiter les exceptions il vaut mieux le faire un niveau au dessus (comme ca tu ne traites les exception qu'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
    public void copyFile(File in, File out) {
        try {
            FileChannel sourceChannel = new FileInputStream(in).getChannel();
            try {
                FileChannel destinationChannel = new FileOutputStream(out).getChannel();
                try {
                    sourceChannel.transferTo(0, sourceChannel.size(), destinationChannel);
                } finally { destinationChannel.close(); }
            } finally { sourceChannel.close(); }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

a++

**n@n¤u** · 04/05/2006, 10h51

Ok d'ac adiGuba, je fais comme tu me le conseille.
Le temps d'exécution est en général le suivant :

Temps d'exécution 1ère méthode : 4060572 ns
Temps d'exécution 2ème méthode : 10065525 ns

Pourquoi le deuxième est moins performant que le premier, alors que ça devrait être l'inverse. Je fais mes manips avec un fichier de 161Ko.

**mavina** · 04/05/2006, 11h05

Salut,

Passage furtif pour remarquer que, il me semble, on a déja eu un sujet comme ça, et qu'il était dit que System.getCurrentTimeMillis() n'était pas fiable sous windows... Par contre je me souviens plus trop ce qu'il fallait utiliser comme fonction, c'était dans Quartz il me semble

mavina, qui fait mine de rien

**adiGuba** · 04/05/2006, 11h13

Salut,

J'optiens des résultats similaires aux tiens... et en fait cela dépend de la taille du fichier...

Pour de petit fichier (j'ai testé avec un de 300 Ko), la première méthode est plus rapide, mais c'est de l'ordre de 5-7 milliseconde (comme pour toi).

Pour de fichier plus gros (j'ai testé avec un de 29 Mo), c'est la seconde avec FileChannel qui est plus rapide, avec une différence de l'ordre de 700 millisecondes...

Donc pour de petit fichier il semble plus rapide de passer par un buffer (et ainsi de charger le fichier en mémoire), alors que pour de gros fichier il vaut mieux passer par FileChannel et le cache du système de fichier...

J'obtiens de résultat très proche pour des fichier d'environ 1.5 Mo...

a++