Taking the d:/a directory as an example, assuming 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 files in the entire directory (recursive)
Ideas:
1.Transfer the directory d:/a.
2. Every time you traverse to a directory in d:/a, iterate over this subdirectory. Therefore, it is necessary to determine whether each element traversed is a directory.
Here are some of the codes from normal 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(); //The code starts here and may be recursive logically infinitely if (dir_1.isDirectory()) { .... } } else { System.out.println(list.getAbsolutePath()); }}The repeated code parts are encapsulated, so the recursive method is used to encapsulate the code and solve the infinite recursive problem. 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
Ideas:
1. Iterate over the given directory. Put the directory name you traversed into the collection.
2. Iterate over each directory element in the collection, and add the traversed subdirectories to the collection. Finally, delete it from the collection after each traversal.
3. In this way, as long as the directory is found, it will continue to traverse until a certain directory is traversed and the next directory at the same level will begin to traverse.
What to consider is what kind of collection to use. First of all, the directory elements in the collection do not need to be sorted, and the subdirectory names in different directories may be repeated. Therefore, the List collection is used instead of the set collection. Because elements are frequently added and deleted, the linkedlist instead of the arraylist collection is used. The most prominent feature of the linkedlist collection is the FIFO queue.
Compared to recursive traversal, the advantage of using queues to traverse the directory is that elements are placed in containers, and they are all in heap memory, making it difficult to overflow memory.
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>(); //Construct a queue File[] list = dir.listFiles(); for (File file : list) { //Transulate the top-level directory if(file.isDirectory()) { System.out.println("dir----->"+file.getAbsolutePath()); file_queue.add(file); } else { System.out.println("file------>"+file.getAbsolutePath()); } } while (!file_queue.isNull()) { //Start from the secondary subdirectory, traverse File subdirs = file_queue.get(); //First get the secondary subdirectory name File[] subFiles = subdirs.listFiles(); for (File subdir: subFiles) { //Transtraight each next-level subdirectory if(subdir.isDirectory()) { System.out.println("dir------>"+subdir.getAbsolutePath()); file_queue.add(subdir); //If there is a subdirectory in the inner layer, add to the queue} 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); //Advanced} public E get() { return linkedlist.removeLast(); //First out} public boolean isNull() { return linkedlist.isEmpty(); }}4.3 Example 3: Tree structure displays files in the entire directory (recursive)
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 iterate through 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(); }}Summarize
The above is the java display directory file list and delete directory introduced by the editor. I hope it will be helpful to everyone. If you have any questions, please leave me a message and the editor will reply to everyone in time. Thank you very much for your support to Wulin.com website!