Comment implémenter les fonctions d'affichage de la liste des fichiers de répertoire et de suppression de répertoire en Java

Prenons le répertoire d:a comme exemple. Supposons que la structure du répertoire D:a soit la suivante :

d:\a
|--a.sql
|--back.log
|--b
| |--e
| | |--1.txt
| | |--2.txt
| | `--3.txt
| `--f
| |--4.txt
| |--5.txt
| `--6.txt
|--c
| |--e
| | |--ace1.txt
| | |--ace2.txt
| | `--ace3.txt
| `--f
| |--4.txt
| |--5.txt
| `--6.txt
`--d
 |--a.java
 |--abc (1).txt
 |--abc (2).txt
 |--abc (3).txt
 |--b.java
 `--c.java

4.1 Exemple 1 : Lister les fichiers dans tout le répertoire (de manière récursive)

Idée :

1. Parcourez le répertoire d:a.

2. Chaque fois qu'un répertoire de d:a est parcouru, ce sous-répertoire est parcouru. Il faut donc déterminer si chaque élément parcouru est un répertoire.

Ce qui suit fait partie du code avant de passer du code ordinaire au code récursif :

File dir = new File("d:/a");
File[] file_list = dir.listFiles();
for (File list : file_list) {
 if (list.isDirectory()) {
 File dir_1 = list.listFiles(); //此处开始代码重复，且逻辑上可能会无限递归下去
 if (dir_1.isDirectory()) {
  ....
 }
 } else {
 System.out.println(list.getAbsolutePath());
 }
}

Pour encapsuler les parties de code répétées, la méthode récursive est utilisée non seulement pour encapsuler le code mais également pour résoudre le problème de récursion infinie. Le code final est le suivant :

import java.io.*;
public class ListAllFiles {
 public static void main(String[] args) {
 File dir = new File("d:/a");
 System.out.println("dir------>"+dir.getAbsolutePath());
 listAll(dir);
 }
 public static void listAll(File dir) {
 File[] file_list = dir.listFiles();
 for (File file : file_list) {
  if (file.isDirectory()) {
  System.out.println("dir------>"+file.getAbsolutePath());
  listAll(file);
  } else {
  System.out.println("file------>"+file.getAbsolutePath());
  }
 }
 }
}

4.2 Exemple 2 : Liste des fichiers (file d'attente) dans tout le répertoire

Idée :

1. Mettez les noms de répertoire parcourus dans la collection.

2. Parcourez chaque élément de répertoire de la collection et ajoutez le sous-répertoire parcouru à la collection. Enfin, chaque fois que le parcours se termine, supprimez un répertoire de la collection.

3. De cette façon, tant qu'un répertoire est trouvé, il continuera à être parcouru jusqu'à ce que tout le répertoire soit parcouru, puis le répertoire suivant du même niveau sera parcouru.

Ce qu’il faut considérer, c’est quel type de collection utiliser. Tout d'abord, les éléments de répertoire de la collection n'ont pas besoin d'être triés et les noms de sous-répertoires dans différents répertoires peuvent être répétés, donc une collection List est utilisée au lieu d'une collection définie. Étant donné que les éléments sont fréquemment ajoutés et supprimés, une liste chaînée est utilisée. au lieu d'une collection arraylist, la fonctionnalité la plus importante de la collection linkedlist est la file d'attente FIFO.

Par rapport au parcours récursif, l'avantage d'utiliser une file d'attente pour parcourir le répertoire est que les éléments sont placés dans le conteneur, ils sont tous dans la mémoire tas et il n'est pas facile de déborder la mémoire.

import java.util.*;
import java.io.*;
public class ListAllFiles2 {
 public static void main(String[] args) {
 File dir = new File("d:/a");
 Queue<File> file_queue = new Queue<File>(); //构建一个队列
 File[] list = dir.listFiles();
 for (File file : list) {  //遍历顶级目录
  if(file.isDirectory()) {
  System.out.println("dir------>"+file.getAbsolutePath());
  file_queue.add(file);
  } else {
  System.out.println("file------>"+file.getAbsolutePath());
  }
 }
 while (!file_queue.isNull()) { //从二级子目录开始，逐层遍历
  File subdirs = file_queue.get(); //先取得二级子目录名称
  File[] subFiles = subdirs.listFiles(); 
  for (File subdir : subFiles) { //遍历每个下一级子目录
  if(subdir.isDirectory()) {
   System.out.println("dir------>"+subdir.getAbsolutePath());
   file_queue.add(subdir); //如果内层还有子目录，添加到队列中
  } else {
   System.out.println("file------>"+subdir.getAbsolutePath());
  }
  }
 }
 }
}

class Queue<E> {
 private LinkedList<E> linkedlist;
 Queue() {
 linkedlist = new LinkedList<E>();
 }
 public void add(E e) {
 linkedlist.addFirst(e); //先进
 }
 public E get() {
 return linkedlist.removeLast(); //先出
 }
 public boolean isNull() {
 return linkedlist.isEmpty();
 }
}

4.3 Exemple 3 : La structure arborescente affiche les fichiers dans tout le répertoire (de manière récursive)

Idées :

1 Répertoriez d'abord les répertoires et les fichiers de premier niveau.

2. S'il s'agit d'un répertoire, ajoutez un symbole de préfixe qui forme une forme d'arbre. Parcourez ensuite ce répertoire, ce qui nécessite un parcours récursif.

import java.io.*;
public class TreeFiles {
 public static void main(String[] args) {
 File dir = new File("d:/a");
 System.out.println(dir.getName());
 listChilds(dir,1);
 }
 public static void listChilds(File f,int level) {
 String prefix = "";
 for(int i=0;i<level;i++) {
  prefix = "| " + prefix;
 }
 File[] files = f.listFiles();
 for (File file : files) {
  if(file.isDirectory()) {
  System.out.println(prefix + file.getName());
  listChilds(file,level+1);
  } else {
  System.out.println(prefix + file.getName());
  }
 }
 }
}

Les résultats sont les suivants :

a
| a.sql
| b
| | e
| | | 1.txt
| | | 2.txt
| | | 3.txt
| | f
| | | 4.txt
| | | 5.txt
| | | 6.txt
| back.log
| c
| | e
| | | ace1.txt
| | | ace2.txt
| | | ace3.txt
| | f
| | | 4.txt
| | | 5.txt
| | | 6.txt
| d
| | a.java
| | abc (1).txt
| | abc (2).txt
| | abc (3).txt
| | b.java
| | c.java

4.4 Supprimer tout le répertoire

import java.io.*;
public class FileDelete {
 public static void main(String[] args) {
 File file = new File("d:/a");
 rm(file);
 }
 public static void rm(File f) {
 if(!f.exists()){
  System.out.println("file not found!");
  return;
 } else if(f.isFile()) {
  f.delete();
  return;
 }
 File[] dir = f.listFiles();
 for(File file : dir) {
  rm(file);
 }
 f.delete();
 }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!