How to implement the functions of displaying directory file list and deleting directory in java

Take the d:\a directory as an example. Assume that the structure in the D:\a directory is as follows:

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 Example 1: List the files in the entire directory (recursively)

Ideas:

1. Traverse the directory d:\a.

2. Each time a directory in d:\a is traversed, this subdirectory is traversed. Therefore, it is necessary to determine whether each traversed element is a directory.

The following is part of the code before going from ordinary code to recursive code:

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());
 }
}

To encapsulate the repeated code parts, the recursive method is used, which not only encapsulates the code, but also solves the problem of infinite recursion. The final code is as follows:

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 Example 2: List files (queue) in the entire directory

Idea:

1. Traverse the given directory. Put the traversed directory names into the collection.

2. Traverse each directory element in the collection, and add the traversed subdirectories to the collection. Finally, every time the traversal ends, delete a directory from the collection.

3. In this way, as long as a directory is found, it will continue to be traversed until a certain directory is traversed, and then the next directory of the same level will be traversed.

What needs to be considered is what kind of collection to use. First of all, directory elements in the collection do not need to be sorted, and subdirectory names in different directories may be repeated, so a List collection is used instead of a set collection. Because elements are frequently added and deleted, a linkedlist is used instead of an arraylist collection. The most prominent feature of the linkedlist collection is the FIFO queue.

Compared with recursive traversal, the advantage of using a queue to traverse the directory is that the elements are placed in the container, they are all in the heap memory, and memory overflow is not easy.

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 Example 3: Tree structure displays files in the entire directory (recursively)

Ideas:

1. First list the first-level directories and files.

2. If it is a directory, add a prefix symbol that forms a tree shape. Then traverse this directory, which requires recursive traversal.

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());
  }
 }
 }
}

The results are as follows:

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 Delete the entire directory

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();
 }
}

The above is the detailed content of How to implement the functions of displaying directory file list and deleting directory in java. For more information, please follow other related articles on the PHP Chinese website!