web-dev-qa-db-fra.com

Java, répertorie uniquement les sous-répertoires d'un répertoire, pas les fichiers

En Java, comment répertorier uniquement les sous-répertoires d'un répertoire?

J'aimerais utiliser la fonctionnalité Java.io.File. Quelle est la meilleure méthode en Java pour le faire? 

javafile
76
Lokesh Paunikar

Vous pouvez utiliser la classe File pour répertorier les répertoires.

File file = new File("/path/to/directory");
String[] directories = file.list(new FilenameFilter() {
  @Override
  public boolean accept(File current, String name) {
    return new File(current, name).isDirectory();
  }
});
System.out.println(Arrays.toString(directories));

Mettre à jour

Le commentaire de l’auteur sur ce post voulait un moyen plus rapide, une excellente discussion ici: Comment récupérer rapidement une liste de répertoires en Java?

Fondamentalement:

  1. Si vous contrôlez la structure du fichier, j'essaierai d'éviter de tomber dans cette situation.
  2. Dans Java NIO.2, vous pouvez utiliser la fonction directory pour renvoyer un itérateur afin de permettre une plus grande mise à l'échelle. La classe de flux de l'annuaire est un objet que vous pouvez utiliser pour parcourir les entrées d'un répertoire.
116
Mohamed Mansour

Une solution Java 8 très simple:

File[] directories = new File("/your/path/").listFiles(File::isDirectory);

Cela équivaut à utiliser un FileFilter (fonctionne aussi avec le vieux Java)

File[] directories = new File("/your/path/").listFiles(new FileFilter() {
    @Override
    public boolean accept(File file) {
        return file.isDirectory();
    }
});
86
headsvk

@ Mohammed Mansour, vous y étiez presque ... l'argument "dir" de ce que vous utilisiez est en fait le chemin actuel, il retournera donc toujours vrai. Afin de voir si l'enfant est un sous-répertoire ou non, vous devez tester cet enfant.

File file = new File("/path/to/directory");
String[] directories = file.list(new FilenameFilter() {
  @Override
  public boolean accept(File current, String name) {
    return new File(current, name).isDirectory();
  }
});
System.out.println(Arrays.toString(directories));
13
Javier Buzzi

Si une solution utilisant Java 7 et NIO.2 vous intéresse, procédez comme suit:

private static class DirectoriesFilter implements Filter<Path> {
    @Override
    public boolean accept(Path entry) throws IOException {
        return Files.isDirectory(entry);
    }
}

try (DirectoryStream<Path> ds = Files.newDirectoryStream(FileSystems.getDefault().getPath(root), new DirectoriesFilter())) {
        for (Path p : ds) {
            System.out.println(p.getFileName());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
7
voo
ArrayList<File> directories = new ArrayList<File>(
    Arrays.asList(
        new File("your/path/").listFiles(File::isDirectory)
    )
);
1
bcangas97

La solution qui a fonctionné pour moi est absente de la liste des réponses. C'est pourquoi je poste cette solution ici:

File[]dirs = new File("/mypath/mydir/").listFiles((FileFilter)FileFilterUtils.directoryFileFilter());

Ici, j'ai utilisé org.Apache.commons.io.filefilter.FileFilterUtils d'Apache commons-io-2.2.jar. Sa documentation est disponible ici: https://commons.Apache.org/proper/commons-io/javadocs/api-2.2/org/Apache/commons/io/filefilter/FileFilterUtils.html

0
Abhishek Oza

J'aimerais utiliser la fonctionnalité Java.io.File,

En 2012 (date de la question) oui, pas aujourd'hui. Java.nio L'API doit être privilégié pour de telles exigences.

Terrible avec tant de réponses, mais pas la manière simple que j'utiliserais, c'est Files.walk().filter().collect().

Globalement, deux approches sont possibles:

1) Files.walk(Path start, ) n’a pas de maxDepth limitations pendant

2) Files.walk(Path start, int maxDepth, FileVisitOption... options) permet de le régler.

Sans spécifier aucune limitation de profondeur, cela donnerait:

Path directory = Paths.get("/foo/bar");

try {
    List<Path> directories =
            Files.walk(directory)
                 .filter(Files::isDirectory)
                 .collect(Collectors.toList());
} catch (IOException e) {
    // process exception
}

Et si pour des raisons historiques, vous devez obtenir une liste de File, vous pouvez simplement ajouter une opération map(Path::toFile) avant la collecte:

Path directory = Paths.get("/foo/bar");

try {
    List<File> directories =
            Files.walk(directory)
                 .filter(Files::isDirectory)
                 .map(Path::toFile)
                 .collect(Collectors.toList());
} catch (IOException e) {
    // process exception
}
0
davidxxx

Étant donné un répertoire de départ en tant que String

  1. Créez une méthode qui prend un chemin String en tant que paramètre. Dans la méthode:
  2. Créer un nouveau Fichier objet basé sur le répertoire de départ
  3. Obtenir un tableau de fichiers dans le répertoire en cours en utilisant la méthode listFiles
  4. Boucle sur le tableau de fichiers
    1. Si c'est un fichier, continuez à boucler
    2. S'il s'agit d'un répertoire, écrivez le nom et recurse sur ce nouveau chemin de répertoire
0
Jonathon Faust

Voici la solution pour mon code. Je viens de faire un petit changement de la première réponse . Ceci listera tous les dossiers seulement dans le répertoire désiré, ligne par ligne:

try {
            File file = new File("D:\\admir\\MyBookLibrary");
            String[] directories = file.list(new FilenameFilter() {
              @Override
              public boolean accept(File current, String name) {
                return new File(current, name).isDirectory();
              }
            });
            for(int i = 0;i < directories.length;i++) {
                if(directories[i] != null) {
                    System.out.println(Arrays.asList(directories[i]));

                }
            }
        }catch(Exception e) {
            System.err.println("Error!");
        }
0
Tabby Auguste

Pour ceux également intéressés par Java 7 et NIO, il existe une solution alternative à la réponse de @ voo ci-dessus . Nous pouvons utiliser un try-with-resources qui appelle Files.find() et une fonction lambda utilisée pour filtrer les répertoires.

import Java.io.IOException;
import Java.nio.file.Files;
import Java.nio.file.Path;
import Java.nio.file.Paths;
import Java.util.stream.Stream;


final Path directory = Paths.get("/path/to/folder");

try (Stream<Path> paths = Files.find(directory, Integer.MAX_VALUE, (path, attributes) -> attributes.isDirectory())) {
    paths.forEach(System.out::println);
} catch (IOException e) {
    ...
}

Nous pouvons même filtrer les répertoires par nom en changeant la fonction lambda:

(path, attributes) -> attributes.isDirectory() && path.toString().contains("test")

ou par date:

final long now = System.currentTimeMillis();
final long yesterday = new Date(now - 24 * 60 * 60 * 1000L).getTime();

// modified in the last 24 hours
(path, attributes) -> attributes.isDirectory() && attributes.lastModifiedTime().toMillis() > yesterday
0
HugoTeixeira