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

以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_queue = new Queue(); //构建一个队列

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{

private LinkedList linkedlist;

Queue() {

linkedlist = new LinkedList();

}

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

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

}

}