Code anormalement lent

Version imprimable

Bonjour à tous

j'ai un code qui est bizarement lent le voici :

Code:

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
 
    private int compare(int delay)
    {
        int count = 0;
 
        //faire une copie de dc2_copy
        ArrayList<decompose> dc2_copy3 = new ArrayList<decompose>();
        for (int k = 0; k < dc2_copy.size(); k++)
        {
            dc2_copy3.add(new decompose());
            dc2_copy3.get(k).start = dc2_copy.get(k).start;
        }
        //on compare dc2_copy3 et dc1
        int s1 = dc1.size();
        for (int i = 0; i < s1; i++)
        {
            double b = dc1.get(i).start;
            int s2 = dc2_copy3.size();
            double a=0;
            for (int j = 0; j < s2; j++)
            {
                //le fait de laisser la ligne suivante seule augmente considérablement le temps de calculs
                a = dc2_copy3.get(j).start;
 
                if (a > b - delay && a <= b + delay)
                {
                    count++;
                    dc2_copy3.get(j).start = -1999999999;
                    j = dc2_copy3.size(); //break
                }
            }
        }
 
        return count;
    }

ce qui est étrange c'est que si je supprime la ligne suivante :

Code:

a = dc2_copy3.get(j).start;

j'ai une exécution quasi instantannée.

la question est pourquoi ? et qu'est-ce que je fais de travers?

merci!

je rajoute la classe "décompose" pour que vous sachiez tout:

Code:

1
2
3
4
5
6
7
8
 
public class decompose {
    public int number;
    public double start;
    public double end;
    public String text = "";
    public String timecodes = "";
}

en fait j'en suis arrivé à la conclusion que l'utilisation d'arraylists ralenti considérablement le code

voici un code assez simple

la première partie est instantannée. et la seconde prends au moins 40 seconde à s'exécuter

pourtant elles font le même nombre de calculs

je ne comprends pas. !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
        double[] dc2_copy = new double[1000000];
        for (int k = 0; k < 1000000; k++)
        {
            dc2_copy[k] = k;
        }
 
        for (int i = 0; i <  1000000; i++)
        {
            for (int j = 0; j < 10000; j++)
            {
                 double a = dc2_copy[j];
            }
        }
 
        JOptionPane.showMessageDialog(frame, "1");

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
        List<Double> number = new ArrayList<Double>();
        for (int k = 0; k < 1000000; k++)
        {
            number.add((double)k);
        }
 
        for (int i = 0; i < 1000000; i++)
        {
            for (int j = 0; j < 10000; j++)
            {
                double a = number.get(j);
            }
        }
 
        JOptionPane.showMessageDialog(frame, "2");

quelqu'un pourrait-il m'aider?

merci!

29/07/2012, 18h12
tchize_

Les list servent à stocker des ensemble de données de taille variable. Dans ton cas, il est donc inutile car la taille de dc2_copy3 est connue à l'avance. En plus, ça n'a aucun sens de consommer plein de mémoire avec des "Decompse" car tu ne fais que stocker un double par entrée et ignorer les autres champs.
De plus, une arraylist qui grandit implique à chaque agrandissement de son stockage interne une copie du tableau. La capacité par défaut étant de 10, on peux supposer que ton tableau interne fasse les agrandissement 20,40,80,160,320,640,1280,2560,5120,10240,20480,... A chaque fois ça consomme du temps et de la mémoire. On peux éviter ça en passant par le constructeur ArrayList(int)

Enfin, pour revenir à ta comparaison, dans le tableau tu stocke un million de double. Dans ton arraylist, tu crée et tu stocke un million d'Objets de type Double, ça consomme un supplément de temps.
29/07/2012, 18h25
thelvin

À noter que dans le premier exemple, si on enlève la ligne a = dc2_copy3.get(j).start;, alors a reste à zéro et on a de bonnes chances de passer dans le if, ce qui fait sortir de la boucle immédiatement. Normal que ce soit plus rapide si on ne fait pas la boucle -_-°.