java显示目录文件列表和删除目录

*/

.hljs {
display: block;
overflow-x: auto;
padding: 0.5em;
color: #333;
background: #f8f8f8;
}

.hljs-comment,
.hljs-template_comment,
.diff .hljs-header,
.hljs-javadoc {
color: #998;
font-style: italic;
}

.hljs-keyword,
.css .rule .hljs-keyword,
.hljs-winutils,
.javascript .hljs-title,
.nginx .hljs-title,
.hljs-subst,
.hljs-request,
.hljs-status {
color: #333;
font-weight: bold;
}

.hljs-number,
.hljs-hexcolor,
.ruby .hljs-constant {
color: #099;
}

.hljs-string,
.hljs-tag .hljs-value,
.hljs-phpdoc,
.tex .hljs-formula {
color: #d14;
}

.hljs-title,
.hljs-id,
.coffeescript .hljs-params,
.scss .hljs-preprocessor {
color: #900;
font-weight: bold;
}

.javascript .hljs-title,
.lisp .hljs-title,
.clojure .hljs-title,
.hljs-subst {
font-weight: normal;
}

.hljs-class .hljs-title,
.haskell .hljs-type,
.vhdl .hljs-literal,
.tex .hljs-command {
color: #458;
font-weight: bold;
}

.hljs-tag,
.hljs-tag .hljs-title,
.hljs-rules .hljs-property,
.django .hljs-tag .hljs-keyword {
color: #000080;
font-weight: normal;
}

.hljs-attribute,
.hljs-variable,
.lisp .hljs-body {
color: #008080;
}

.hljs-regexp {
color: #009926;
}

.hljs-symbol,
.ruby .hljs-symbol .hljs-string,
.lisp .hljs-keyword,
.tex .hljs-special,
.hljs-prompt {
color: #990073;
}

.hljs-built_in,
.lisp .hljs-title,
.clojure .hljs-built_in {
color: #0086b3;
}

.hljs-preprocessor,
.hljs-pragma,
.hljs-pi,
.hljs-doctype,
.hljs-shebang,
.hljs-cdata {
color: #999;
font-weight: bold;
}

.hljs-deletion {
background: #fdd;
}

.hljs-addition {
background: #dfd;
}

.diff .hljs-change {
background: #0086b3;
}

.hljs-chunk {
color: #aaa;
}

#container {
padding: 15px;
}
pre {
border: 1px solid #ccc;
border-radius: 4px;
display: block;
background-color: #f8f8f8;
}
pre code {
white-space: pre-wrap;
}
.hljs,
code {
font-family: Monaco, Menlo, Consolas, 'Courier New', monospace;
}
:not(pre) > code {
padding: 2px 4px;
font-size: 90%;
color: #c7254e;
background-color: #f9f2f4;
white-space: nowrap;
border-radius: 4px;
}
-->

以d:\a目录为例，假设D:\a目录内的结构如下：

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 示例1：列出整个目录中的文件(递归)

思路：
1.遍历目录d:\a。
2.每遍历到d:\a中的一个目录就遍历这个子目录。因此需要判断每个遍历到的元素是否是目录。

以下是从普通代码到递归代码前的部分代码：

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

对重复的代码部分进行封装，于是使用递归方法，既封装代码，又解决无限递归问题。最终代码如下：

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 示例2：列出整个目录中的文件(队列)

思路：
1.遍历给定目录。将遍历到的目录名放进集合中。
2.对集合中的每个目录元素进行遍历，并将遍历到的子目录添加到集合中，最后每遍历结束一个目录就从集合中删除它。
3.这样一来，只要发现目录，就会一直遍历下去，直到某个目录整个都遍历完，开始遍历下一个同级目录。

需要考虑的是使用什么样的集合。首先集合内目录元素无需排序、不同目录内子目录名可能重复，因此使用List集合而非set集合，又因为频繁增删元素，因此使用linkedlist而非arraylist集合，linkedlist集合最突出的特性就是FIFO队列。

相比于递归遍历，使用队列遍历目录的好处是元素放在容器中，它们都在堆内存中，不容易内存溢出。

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 示例3：树形结构显示整个目录中的文件(递归)

思路：
1.先列出一级目录和文件。
2.如果是目录，则加一个构成树形的前缀符号。然后再遍历这个目录，在此需要递归遍历。

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

结果如下：

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 删除整个目录

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

注：若您觉得这篇文章还不错请点击右下角推荐，您的支持能激发作者更大的写作热情，非常感谢！