Quel serait le moyen le plus rapide de lister les noms de fichiers de plus de 1000 répertoires et sous-répertoires?
EDIT; Le code actuel que j’utilise est:
import Java.io.File;
public class DirectoryReader {
static int spc_count=-1;
static void Process(File aFile) {
spc_count++;
String spcs = "";
for (int i = 0; i < spc_count; i++)
spcs += " ";
if(aFile.isFile())
System.out.println(spcs + "[FILE] " + aFile.getName());
else if (aFile.isDirectory()) {
System.out.println(spcs + "[DIR] " + aFile.getName());
File[] listOfFiles = aFile.listFiles();
if(listOfFiles!=null) {
for (int i = 0; i < listOfFiles.length; i++)
Process(listOfFiles[i]);
} else {
System.out.println(spcs + " [ACCESS DENIED]");
}
}
spc_count--;
}
public static void main(String[] args) {
String nam = "D:/";
File aFile = new File(nam);
Process(aFile);
}
}
Cela a l'air bien (passant récursivement dans le répertoire) Le goulot d'étranglement sera tout le fichier que vous devez faire, l'optimisation de votre Java ne montrera aucune amélioration réelle.
Comme cette réponse apparaît au-dessus de Google, j'ajoute une solution Java 7 nio pour répertorier tous les fichiers et répertoires. Cela prend environ 80% moins de temps sur mon système.
try {
Path startPath = Paths.get("c:/");
Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path dir,
BasicFileAttributes attrs) {
System.out.println("Dir: " + dir.toString());
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
System.out.println("File: " + file.toString());
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Path file, IOException e) {
return FileVisitResult.CONTINUE;
}
});
} catch (IOException e) {
e.printStackTrace();
}
La seule amélioration consiste à supprimer static spc_count
et à passer la chaîne spcs
en tant que paramètre à Process.
public static void main(String[] args) {
String nam = "D:/";
File aFile = new File(nam);
Process("", aFile);
}
Et lorsque vous effectuez un appel récursif,
static void Process( String spcs, File aFile) {
...
Process(spcs + " ", listOfFiles[i]);
...
}
De cette façon, vous pouvez appeler cette méthode à partir de plusieurs threads.
Jusqu'à ce que Java 7 présente le nouveau Java.nio.file classes (comme DirectoryStream
), je crains que ce que vous avez déjà ne soit le plus rapide.
Si vous êtes prêt à utiliser une bibliothèque tierce, consultez javaxt-core . Il inclut une recherche de répertoire multithread récursive qui devrait être plus rapide que de parcourir un répertoire à la fois. Il y a quelques exemples ici:
http://www.javaxt.com/javaxt-core/io/Directory/Recursive_Directory_Search
J'ai écrit un code beaucoup plus simple .... Essayez ceci ... Il montrera tous les dossiers, sous-dossiers et fichiers ...
int Files=0,Directory=0,HiddenFiles=0,HiddenDirectory=0;
public void listf(String directoryName){
File file=new File(directoryName);
File[] fileList=file.listFiles();
if(fileList!=null){
for(int i=0;i<fileList.length;i++){
if(fileList[i].isHidden()){
if(fileList[i].isFile())
{
System.out.println(fileList[i]);
HiddenFiles++;
}
else{
listf(String.valueOf(fileList[i]));
HiddenDirectory++;
}
}
else if (fileList[i].isFile()) {
//System.out.println(fileList[i]);
Files++;
}
else if(fileList[i].isDirectory()){
Directory++;
listf(String.valueOf(fileList[i]));
}
}
}
}
public void Numbers(){
System.out.println("Files: "+Files+" HiddenFiles: "+HiddenFiles+"Hidden Directories"+HiddenDirectory+" Directories: "+Directory);`
}