Parser arborescence fichier

Version imprimable

Hello,

Comment récupérer l'ensemble des fichiers d'un certain type (par exemple des fichiers dont l'extension est .xml) dans l'ensemble des sous répertoires d'un répertoire donné ?
Si vous avez une solution optimisé, car je suis soumis a une contrainte de perf ^^

Solution en cours mais moyenne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void listeRepertoire ( File dir ) {
    System.out.println ( dir.getAbsolutePath());
    if(dir.endsWith(".xml"))
      process();
 
    if ( dir.isDirectory ( ) ) {
            File[] list = dir.listFiles();
            for ( int i = 0; i < list.length; i++) {
                    // Appel récursif sur les sous-répertoires
                    listeRepertoire( list[i]);
                    if(i==5) break;
            } 
    } 
 }

Merci pour votre aide.

Re: Parser arborescence fichier

Citation:

Envoyé par rgomes

Hello,

Comment récupérer l'ensemble des fichiers d'un certain type (par exemple des fichiers dont l'extension est .xml) dans l'ensemble des sous répertoires d'un répertoire donné ?
Si vous avez une solution optimisé, car je suis soumis a une contrainte de perf ^^

Merci pour votre aide.

Solution en cours mais moyenne :

public static void listeRepertoire ( File dir ) {
System.out.println ( dir.getAbsolutePath());
if(dir.endsWith(".xml"))
process();

if ( dir.isDirectory ( ) ) {
File[] list = dir.listFiles();
for ( int i = 0; i < list.length; i++) {
// Appel récursif sur les sous-répertoires
listeRepertoire( list[i]);
if(i==5) break;
}
}
}

:tagcode:

Je ne sais pas si au niveau perf c'est mieux mais bon :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public static void listeRepertoire(File dir, final String ...exts ) { System.out.println ( dir.getAbsolutePath()); File[] files = dir.listFiles(new FileFilter() { public boolean accept(File f) { boolean res = f.isDirectory(); for(String s : exts) { if(f.getName().endsWith(s)) { res = true; break; } } return res; } }); for(File f : files) { if(f.isDirectory()) { listeRepertoire(f, exts); } else { process(); } } }

En fait je pense que mon code précedent peut être optimisé en construisant le FileFilter à l'exterieur de la methode et en le passant en paramètre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public static void listeRepertoire(File dir, FileFilter filter) {
     System.out.println ( dir.getAbsolutePath());
     File[] files = dir.listFiles(filter);
     for(File f : files) {
           if(f.isDirectory()) {
                listeRepertoire(f, filter);
           }
           else {
                process();
           }
    }
}

Cela évite de créer un objet à chaque appel récursif.

17/01/2006, 18h02
rgomes

Je ne vois pas ce que ta proposition apporte et surtout en passant le filtre, par exemple "fichier terminant par .xml" je n'aurai plus la liste des répertoires et continuer la récursivité ??
17/01/2006, 18h11
adiGuba

Salut,

Le filtre retourne true si c'est un répertoire OU un fichier qui se termine par *.xml

Et il te permet d'éviter de traiter les autres fichiers...

a++

Perso j'utilise les classes suivantes de cette maniere :

Code:

1
2
3
4
5
6
7
 
FileTreeWalker walker = new FileTreeWalker(directory, new UnixGlobFileFilter("*.xml"));
walker.walk(new FileTreeWalk() {
  public void walk(File path) {
    System.out.println(path);
  }
});

Tu mets ca dans un thread et puis le probleme est regle. Tu peux utiliser un autre FileFilter que l'UnixGlobFileFilter mais il permet de specifier simplement n'importe quel type de fichier. Les classes :

Code:

1
2
3
4
5
6
7
8
 
package org.progx.io;
 
import java.io.File;
 
public interface FileTreeWalk {
    public void walk(File path);
}

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
36
37
38
39
40
41
42
43
44
45
46
47
48
 
package org.progx.io;
 
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
 
public class FileTreeWalker {
    private File path;
    private static final FileFilter directoryFilter = new FileFilter() {
        public boolean accept(File pathname) {
            return pathname.isDirectory();
        }
    };
    private FileFilter filter;
 
    public FileTreeWalker(File path) throws IOException {
        this(path, new FileFilter() {
            public boolean accept(File pathname) {
                return pathname.isFile();
            }
        });
    }
 
    public FileTreeWalker(File path, FileFilter filter) throws IOException {
        if (path == null || !path.exists() || path.isFile()) {
            throw new IOException("Path " + path + " is not a valid directory.");
        }
        this.path = path;
        this.filter = filter;
    }
 
    public void walk(FileTreeWalk walk) {
        walkDirectory(walk, path);
    }
 
    private void walkDirectory(FileTreeWalk walk, File dir) {
        File[] files = dir.listFiles(filter);
        for (File file: files) {
            walk.walk(file);
        }
 
        File[] dirs = dir.listFiles(directoryFilter);
        for (File subDir: dirs) {
            walkDirectory(walk, subDir);
        }
    }
}

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
package org.progx.io;
 
import java.io.FileFilter;
import java.io.File;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
 
/**
 * User: gfx
 * Date: 3 juin 2005
 * Time: 15:00:22
 */
public class UnixGlobFileFilter implements FileFilter {
    private Pattern pattern;
 
    public UnixGlobFileFilter(String filter) {
        pattern = Pattern.compile(globToRegex(filter));
    }
 
    public boolean accept(File file) {
        String path = file.getName();
        Matcher matcher = pattern.matcher(path);
        return matcher.matches();
    }
 
    private String globToRegex(String glob) {
        char c = '\0';
        boolean escape = false;
        boolean enclosed = false;
        StringBuffer buffer = new StringBuffer(glob.length());
 
        for (int i = 0; i < glob.length(); i++) {
            c = glob.charAt(i);
 
            if (escape) {
                buffer.append('\\');
                buffer.append(c);
                escape = false;
                continue;
            }
 
            switch (c) {
                case '*':
                    buffer.append('.').append('*');
                    break;
                case '?':
                    buffer.append('.');
                    break;
                case '\\':
                    escape = true;
                    break;
                case '.':
                    buffer.append('\\').append('.');
                    break;
                case '{':
                    buffer.append('(');
                    enclosed = true;
                    break;
                case '}':
                    buffer.append(')');
                    enclosed = false;
                    break;
                case ',':
                    if (enclosed)
                        buffer.append('|');
                    else
                        buffer.append(',');
                    break;
                default:
                    buffer.append(c);
            }
        }
        return buffer.toString();
    }
}