Discussion :

[tarekphp]

Bonjour;
j'arrive a récupere une liste de plus de 10000 Fichiers mais sans le path (ma liste est de type String[])

et je connais le path du coup je voudrais concaténer a toute la lise ce path avec une fonction qui n'allourdi pas trop l'execution.

exemple :
je recupére
Fichier1
Fichier2
Fichier3
Fichier4

et je voudrais avoir :
path/Fichier1
path/Fichier2
path/Fichier3
path/Fichier4

voila en vous remerciant

[tchize_]

tu fait un boucle sur l'ensemble des élément, tu fait la concaténation (opérateur +) et tu remet dans le tableau à la même position.

[bigbear19]

Salut,

Je ne vois pas vraiment d'autres moyens que de faire une boucle sur ta liste...
Si tu n'as pas besoin que tous les éléments soient préfixés du path, on peut essayer d'optimiser le parcours.

[Yomhgui]

Est-ce que la bonne idée est vraiment celle-là ?

Tu possèdes un tableau de 10000 entrée de type String, tel que:

{

"String 1",
"String 2",
....
"String 10000"

}


Une valeur de ce tableau est utilisée en y ajoutant un autre chaîne dont la valeur est constante:

"C:\\My Folder 1\\My Folder 1.1\\My Folder 1.1.1\\"

Est-il vraiment nécessaire de créer le tableau:

{

"C:\\My Folder 1\\My Folder 1.1\\My Folder 1.1.1\\String 1",
"C:\\My Folder 1\\My Folder 1.1\\My Folder 1.1.1\\String 2",
....
"C:\\My Folder 1\\My Folder 1.1\\My Folder 1.1.1\\String 10000"

}


qui est évidemment beaucoup plus consommateur de mémoire ?

Un objet enveloppe du tableau en question avec une méthode elementAt(int index) : String qui retourne la chaîne de caractères sous sa forme utilisable, comme dans:

Code :

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

1
2
3
public String elementAt(int index) {
    return "C:\\My Folder 1\\My Folder 1.1\\My Folder 1.1.1\\" + _value[index];
}

serait peut être plus intéressant ?

[tarekphp]

re Bonjour
merci pour vos réponse.
effectivement je fait une boucle avec l'oprateur "+" pour concatener mais moi je me demandé si yavais un autre moyen plus performant sachant que dans ma liste ya plus de 10 000 entrée.

le return ne m'aidera pas enormément car je dois fournir à la sortie de ma méthode une liste de fichiers sur laquelle j'effectue d'autres taches.


en tout cas merci

[tchize_]

en même temps, 10.000 opération string, si tu dois le faire qu'une fois, je vois pas ou est la perte de performance. Evidement, si tu dois le faire 500 fois par secondes, faut commencer à s'inquiéter

[Yomhgui]

le return ne m'aidera pas enormément car je dois fournir à la sortie de ma méthode une liste de fichiers sur laquelle j'effectue d'autres taches.

Ce qui n'est pas incompatible de ce que je disais. Avec un objet adapté, tu peux faire les manipulations que tu veux et retourner le résultats final. En changeant la méthode elementAt(int) de tout à l'heure:

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
 
public class FileProcessor
    implements Iterable<<MON_TYPE_RESULTAT>> {
 
    /**
     * Chemin du dossier racine où sont localisés les fichiers
     * histoire de faire un peu configurable.
     */
    private String _pathname;
    private List<String> _elements = new ArrayList<String>();
 
    public FileProcessor(String pathname) {
        _pathname = pathname;
    }
 
    public void add(String element) {
        _elements.add(element);
    }
 
    public int elementCount() {
         return _elements.size();
    }
 
    public <MON_TYPE_RESULTAT> elementAt(int index) {
 
        File file = new File(_pathname  +  _elements.get(index));
        if (file.exists()) {
 
            // faire toutes les manipulations nécessaires avec file
            // et créer une instance de <MON_TYPE_RESULTAT> qui
            // répond au besoin
 
            return <MON_TYPE_RESULTAT>;
 
        } else
            return null; // Par exemple... ou alors throw new Exception, etc, etc...
 
    }
 
    public Iterator<<MON_TYPE_RESULTAT>> iterator() {
         return /*
             une petite implémentation d'itérateur qui permet de parcourir
             les éléments "calculés", ça sera très pratique pour manipuler
             l'objet dans une boucle.
         */;
    }
 
}

en même temps, 10.000 opération string, si tu dois le faire qu'une fois, je vois pas ou est la perte de performance. Evidement, si tu dois le faire 500 fois par secondes, faut commencer à s'inquiéter

Tout à fait d'accord, il n'y a aucun problème de performances avec une petite liste comme celle-là, raison de plus plus pour ne pas conserver les données concaténées en mémoire (dans ce domaine, il n'y a pas de petites économies). A plus forte raison si l'opération de concaténation n'est de toutes façons réalisée qu'une seule et unique fois, autant la faire uniquement au moment où elle est nécessaire.