JAVA利用递归的方法删除一个文件夹以及文件夹下所有的子文件

JAVA遍历⽂件夹下的所有⽂件JAVA遍历⽂件下的所有⽂件和⽂件夹@Testpublic void traverseFolder1( ) {String path = "D:\\TEST";int fileNum = 0;int folderNum = 0;int foldeNum = 0;File file = new File(path);if (file.exists()) {LinkedList<File> list = new LinkedList<File>();//list()⽅法是返回某个⽬录下的所有⽂件和⽬录的⽂件名，返回的是String数组//listFiles()⽅法是返回某个⽬录下所有⽂件和⽬录的绝对路径，返回的是File数组File[] files = file.listFiles();for (File file2 : files) {if (file2.isDirectory()) {System.out.println("⽂件夹:" + file2.getAbsolutePath());list.add(file2);foldeNum++;} else {System.out.println("⽂件:" + file2.getAbsolutePath());fileNum++;}}File temp_file;while (!list.isEmpty()) {temp_file = list.removeFirst();//删除第⼀个元素，也就是找到数组中的第⼀个元素返回⼀个File去判断，说⽩了就是循环分别找到每个⽂件下⾯对应的是⽂件还是⽂件夹，如果循环下⼀级还是⽂件夹则继续循环直到结束（思想就是⼀层⼀层去判断查找知道找到所有的⽂件和⽂件夹，不明⽩看下⾯的例⼦。

）files = temp_file.listFiles();for (File file2 : files) {if (file2.isDirectory()) {//如果是个⽬录(⽂件夹)则返回trueSystem.err.println("⽂件夹:" + file2.getAbsolutePath());list.add(file2);folderNum++;} else {//输出⽂件System.out.println("⽂件:" + file2.getAbsolutePath());//返回⽂件的完整路径。

directory类的方法Directory类的介绍在Java中，Directory类是一个很常见的类，它用于操作目录或文件夹，可以创建、删除、修改目录以及获取目录的名称、路径等信息。

Directory类是一种非常方便和常用的工具类，可以让我们更加高效地处理目录以及文件夹的相关操作。

Directory类的基本方法1. 创建目录在Java中，我们可以使用mkdir()方法创建一个新的目录，例如：```File file = new File("C:\\test");if (!file.exists()) {file.mkdir();}```上面的代码意思是如果C盘下没有一个test目录，就创建一个名为test的目录。

还可以使用mkdirs()方法创建多级目录：```File file = new File("C:\\test\\demo\\temp");if (!file.exists()) {file.mkdirs();}```上面的代码意思是如果C盘下没有test目录，则先创建test目录，然后在其中创建demo目录和temp目录。

2. 删除目录在Java中，我们可以使用delete()方法删除目录，例如：```File file = new File("C:\\test");if (file.exists()) {file.delete();}```上面的代码意思是如果C盘下有一个名为test的目录，就删除这个目录。

需要注意的是，删除目录时，必须保证该目录为空，否则会抛出异常。

可以使用deleteOnExit()方法在程序退出时删除目录。

3. 修改目录在Java中，我们可以使用renameTo()方法修改目录的名称，例如：```File oldFile = new File("C:\\test\\origin");File newFile = new File("C:\\test\\new");if (oldFile.exists() && !newFile.exists()) {oldFile.renameTo(newFile);}```上面的代码将test目录下的origin目录名称修改为new。

Java移动⽂件夹及其所有⼦⽂件与⼦⽂件夹在Java移动⽂件夹及其所有⼦⽂件与⼦⽂件夹可以有如下的⼀段简单的⽅法来说明：public static void moveFolder(String oldPath, String newPath) {//先复制⽂件copyFolder(oldPath, newPath);//则删除源⽂件，以免复制的时候错乱deleteDir(new File(oldPath));}不应该直接剪切⽂件，防⽌在剪切的时候出错，导致这样那样的问题。

在Java复制⽂件夹及其所有⼦⽂件与⼦⽂件夹，在（）⼀⽂中已经详细说过了。

关键是删除⽂件夹及其⼦⽂件与⼦⽂件夹。

在Java中，File类的delete()⽅法只能删除为空的⽂件夹或者单个⽂件，因此必须遍历整个⽂件夹，先从最内层的⽂件夹中的⽂件开始，进⾏递归删除，具体⽅法如下：// 删除某个⽬录及⽬录下的所有⼦⽬录和⽂件public static boolean deleteDir(File dir) {// 如果是⽂件夹if (dir.isDirectory()) {// 则读出该⽂件夹下的的所有⽂件String[] children = dir.list();// 递归删除⽬录中的⼦⽬录下for (int i = 0; i < children.length; i++) {// File f=new File（String parent ，String child）// parent抽象路径名⽤于表⽰⽬录，child 路径名字符串⽤于表⽰⽬录或⽂件。

// 连起来刚好是⽂件路径boolean isDelete = deleteDir(new File(dir, children[i]));// 如果删完了，没东西删，isDelete==false的时候，则跳出此时递归if (!isDelete) {return false;}}}// 读到的是⼀个⽂件或者是⼀个空⽬录，则可以直接删除return dir.delete();}因此，整个⽅法连起来就是这个样⼦，把C盘下的A⽂件夹及其所有⼦⽂件与⼦⽂件夹，移动到F盘，并且重新命名：import java.io.*;public class CutTest {// 删除某个⽬录及⽬录下的所有⼦⽬录和⽂件public static boolean deleteDir(File dir) {// 如果是⽂件夹if (dir.isDirectory()) {// 则读出该⽂件夹下的的所有⽂件String[] children = dir.list();// 递归删除⽬录中的⼦⽬录下for (int i = 0; i < children.length; i++) {// File f=new File（String parent ，String child）// parent抽象路径名⽤于表⽰⽬录，child 路径名字符串⽤于表⽰⽬录或⽂件。

java 树形结构递归过滤Java树形结构递归过滤在Java编程中，树形结构是一种非常常见的数据结构。

它由一系列的节点构成，这些节点按照一定的层次关系连接起来。

树形结构可以用于模拟现实中的各种场景，比如文件系统、组织结构等。

然而，在实际应用中，我们经常需要对树形结构进行一些操作，如搜索、过滤等。

本文将重点讨论如何使用递归来对树形结构进行过滤操作。

第一步：了解树形结构在开始之前，首先要了解树形结构的基本概念。

树形结构由一个根节点和若干个子节点组成，每个节点包含数据以及连接到下一层节点的指针。

节点之间的连接关系遵循一定的层次关系，即每个节点最多有一个父节点和多个子节点。

# 示例：文件系统我们以文件系统为例来说明树形结构的概念。

在文件系统中，根节点表示整个文件系统，它的子节点表示根目录下的所有文件和文件夹。

每个子节点又可以有自己的子节点，构成了一个递归的树形结构。

例如，我们可以构建如下的文件系统树形结构：C:\Program FilesJavajdkbinlibApacheTomcatconflibUsersAliceBob在这个示例中，根节点表示C盘，它有两个子节点Program Files和Users。

以此类推，我们可以进一步展开每个子节点，直到最底层的叶子节点。

第二步：树形结构的递归过滤接下来，我们将树形结构的递归过滤问题进行具体讨论。

假设我们有一个文件系统树形结构，我们想要找出其中所有包含某个关键词的文件或文件夹。

这时，递归过滤就能帮助我们实现这个目标。

# 实现思路首先，我们需要定义一个递归函数来实现树形结构的遍历和过滤操作。

这个函数的输入参数包括当前节点、过滤关键词以及存储结果的数据结构。

函数的主要逻辑如下：1. 判断当前节点是否符合过滤条件，如果是，则将该节点添加到结果中。

2. 判断当前节点是否有子节点，如果有，则递归调用本函数继续遍历子节点。

3. 返回结果。

# 递归函数代码下面是一个简单的递归过滤函数的实现：javapublic void recursiveFilter(Node node, String keyword, List<Node>result) {if (node.getName().contains(keyword)) {result.add(node);}if (node.hasChildren()) {for (Node child : node.getChildren()) {recursiveFilter(child, keyword, result);}}}在这个代码中，我们通过判断节点的名称是否包含给定的关键词来决定是否将该节点添加到结果中。

java中File类应⽤遍历⽂件夹下所有⽂件本⽂要求遍历指定⽂件夹下的所有⽂件，包括⼦⽂件夹下的⽂件，供⼤家参考，具体内容如下代码：package 遍历⽂件夹所有⽂件;import java.io.File;public class Test {public static void main(String[] args){File file=new File("D:\\tcb\\周总结");filesDirs(file);}//使⽤递归遍历⽂件夹及⼦⽂件夹中⽂件public static void filesDirs(File file){//File对象是⽂件或⽂件夹的路径，第⼀层判断路径是否为空if(file!=null){//第⼆层路径不为空，判断是⽂件夹还是⽂件if(file.isDirectory()){//进⼊这⾥说明为⽂件夹，此时需要获得当前⽂件夹下所有⽂件，包括⽬录File[] files=file.listFiles();//注意:这⾥只能⽤listFiles()，不能使⽤list()//files下的所有内容，可能是⽂件夹，也可能是⽂件，那么需要⼀个个去判断是⽂件还是⽂件夹，这个判断过程就是这⾥封装的⽅法 //因此可以调⽤⾃⼰来判断，实现递归for (File flies2:files) {filesDirs(flies2);}}else{System.out.println("⽂件名字"+file);}}else{System.out.println("⽂件不存在");}}}结果：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

Java使用线程池递归压缩文件夹下面的所有子文件本文将介绍Java中利用线程池递归的方式压缩文件夹下面的所有子文件，具体方法如下：Gzip单个文件压缩对于单个文件使用GZip压缩。

1.package date0805.demo1;2.3.import java.io.BufferedInputStream;4.import java.io.BufferedOutputStream;5.import java.io.File;6.import java.io.FileInputStream;7.import java.io.FileOutputStream;8.import java.io.InputStream;9.import java.io.OutputStream;10.import java.util.zip.GZIPOutputStream;11.12.public class GZipRunnable implements Runnable{13.14.private final File file;15.16.public GZipRunnable(File file){17.this.file=file;18.}19.20.@Override21.public void run(){22.if(!file.getName().endsWith(".gz")){23.File outputFile=new File(file.getParent(),file.getName()+".gz");24.if(!outputFile.exists()){25.CountTime countTime=new CountTime(file);26.Thread t=new Thread(countTime);27.t.start();28.try(29.InputStream in=new BufferedInputStream(new FileInputStream(file));30.OutputStream out=new BufferedOutputStream(newGZIPOutputStream(new FileOutputStream(outputFile)));31.){32.int b;33.while((b=in.read())!=-1)34.out.write(b);35.out.flush();36.}catch(Exception ex){37.ex.printStackTrace();38.}39.t.interrupt();40.}else{41.System.out.println(outputFile+"文件已经存在，无法压缩!");42.}43.}44.}45.}创建线程池进行递归压缩要实现对一个文件夹下面的所有的子文件进行压缩，首先递归找出所有子文件，然后调用压缩线程进行压缩。

JAVA遍历⽂件夹下的所有⽂件JAVA 遍历⽂件夹下的所有⽂件(递归调⽤和⾮递归调⽤)1.不使⽤递归的⽅法调⽤.public void traverseFolder1(String path) {int fileNum = 0, folderNum = 0;File file = new File(path);if (file.exists()) {LinkedList<File> list = new LinkedList<File>();File[] files = file.listFiles();for (File file2 : files) {if (file2.isDirectory()) {System.out.println("⽂件夹:" + file2.getAbsolutePath());list.add(file2);foldeNum++;} else {System.out.println("⽂件:" + file2.getAbsolutePath());fileNum++;}}File temp_file;while (!list.isEmpty()) {temp_file = list.removeFirst();files = temp_file.listFiles();for (File file2 : files) {if (file2.isDirectory()) {System.out.println("⽂件夹:" + file2.getAbsolutePath());list.add(file2);folderNum++;} else {System.out.println("⽂件:" + file2.getAbsolutePath());fileNum++;}}}} else {System.out.println("⽂件不存在!");}System.out.println("⽂件夹共有:" + folderNum + ",⽂件共有:" + fileNum);}2.使⽤递归的⽅法调⽤.public void traverseFolder2(String path) {File file = new File(path);if (file.exists()) {File[] files = file.listFiles();if (files.length == 0) {System.out.println("⽂件夹是空的!");return;} else {for (File file2 : files) {if (file2.isDirectory()) {System.out.println("⽂件夹:" + file2.getAbsolutePath());traverseFolder2(file2.getAbsolutePath());} else {System.out.println("⽂件:" + file2.getAbsolutePath());}}}} else {System.out.println("⽂件不存在!");}}3,public static List<File> getFileList(String strPath) {File dir = new File(strPath);File[] files = dir.listFiles(); // 该⽂件⽬录下⽂件全部放⼊数组if (files != null) {for (int i = 0; i < files.length; i++) {String fileName = files[i].getName();if (files[i].isDirectory()) { // 判断是⽂件还是⽂件夹getFileList(files[i].getAbsolutePath()); // 获取⽂件绝对路径} else if (fileName.endsWith("avi")) { // 判断⽂件名是否以.avi结尾String strFileName = files[i].getAbsolutePath();System.out.println("---" + strFileName); filelist.add(files[i]);} else {continue;}}}return filelist;}。

java中delete的用法Java是一种广泛使用的编程语言，具有强大的删除功能。

在Java中，删除操作可以应用于删除文件、删除对象、删除数组元素等多个方面。

本文将详细介绍Java中delete的用法。

1. 删除文件在Java中，我们可以使用如下代码删除文件：```javaimport java.io.File;public class DeleteFileExample {public static void main(String[] args) {// 要删除的文件路径String filePath = "C:/temp/file.txt";// 创建File对象File file = new File(filePath);// 判断文件是否存在if (file.exists()) {// 删除文件boolean result = file.delete();if (result) {System.out.println("文件删除成功");} else {System.out.println("文件删除失败");}} else {System.out.println("文件不存在");}}}```上述代码首先创建一个`File`对象，然后通过调用`exists()`方法判断文件是否存在。

如果文件存在，则调用`delete()`方法删除文件。

删除文件时，如果文件不存在或者删除失败，`delete()`方法会返回`false`，否则返回`true`。

2. 删除文件夹（包括文件夹下的所有文件和子文件夹）要删除文件夹以及其子文件夹和文件，可以使用递归算法。

以下是一个示例代码：```javaimport java.io.File;public class DeleteFolderExample {public static void main(String[] args) {// 要删除的文件夹路径String folderPath = "C:/temp";// 创建File对象File folder = new File(folderPath);// 判断文件夹是否存在if (folder.exists()) {deleteFolder(folder);System.out.println("文件夹删除成功");} else {System.out.println("文件夹不存在");}}// 递归删除文件夹及其子文件夹和文件public static void deleteFolder(File folder) {File[] files = folder.listFiles();if (files != null) {for (File file : files) {// 如果是文件，则直接删除if (file.isFile()) {file.delete();}// 如果是文件夹，则递归调用删除文件夹的方法else {deleteFolder(file);}}}// 删除空文件夹folder.delete();}}```上述代码首先创建一个`File`对象，然后通过调用`exists()`方法判断文件夹是否存在。

本文由我司收集整编，推荐下载，如有疑问，请与我司联系Java 代码完成删除文件、文件夹操作2017/08/04 0 Java 代码完成删除文件、文件夹操作import java.io.File;/*** 删除文件和目录**/public class DeleteFileUtil { /** * 删除文件，可以是文件或文件夹** @param fileName * 要删除的文件名* @return 删除成功返回true，否则返回false */ public static boolean delete(String fileName) { File file = new File(fileName); if (!file.exists()) { System.out.println(“删除文件失败:”+ fileName + “不存在！”);return false; } else { if (file.isFile()) return deleteFile(fileName); else return deleteDirectory(fileName); } } /** * 删除单个文件* * @param fileName * 要删除的文件的文件名* @return 单个文件删除成功返回true，否则返回false */ public static boolean deleteFile(String fileName) { File file = new File(fileName); // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除if (file.exists() file.isFile()) { if (file.delete()) { System.out.println(“删除单个文件”+ fileName + “成功！”);return true; } else { System.out.println(“删除单个文件”+ fileName + “失败！”);return false; } } else { System.out.println(“删除单个文件失败：”+ fileName + “不存在！”); return false; } } /** * 删除目录及目录下的文件* * @param dir * 要删除的目录的文件路径* @return 目录删除成功返回true，否则返回false */ public static boolean deleteDirectory(String dir) { // 如果dir 不以文件分隔符结尾，自动添加文件分隔符if (!dir.endsWith(File.separator)) dir = dir + File.separator; File dirFile = new File(dir); // 如果dir 对应的文件不存在，或者不是一个目录，则退出if ((!dirFile.exists()) || (!dirFile.isDirectory())) { System.out.println(“删除目录失败：”+ dir + “不存在！”); return false; } boolean flag = true; // 删除文件夹中的所有文件包括子目录File[] files = dirFile.listFiles(); for (int i = 0; i files.length; i++) { // 删除子文件if (files[i].isFile()) { flag = DeleteFileUtil.deleteFile(files[i].getAbsolutePath()); if (!flag) break; } // 删除子目录else if (files[i].isDirectory()) { flag = DeleteFileUtil.deleteDirectory(files[i] .getAbsolutePath()); if (!flag) break; } } if (!flag) { System.out.println(“删除目录失败！”);return false; } // 删除当前目录if。

java文件删除方法Java文件删除方法Java是一种广泛使用的编程语言，用于开发各种各样的应用程序和软件。

对于开发人员来说，文件操作是常见的任务之一，其中包括删除文件。

在Java中，你可以使用以下方法删除文件：1. 使用File类删除文件File类是Java中用于文件和目录操作的重要类。

你可以使用该类的delete()方法删除一个文件。

该方法返回一个布尔值，表示是否已成功删除该文件。

例如，要删除名为“test.txt”的文件，可以使用以下代码：```File file = new File("test.txt");if (file.delete()){System.out.println("文件删除成功！");} else {System.out.println("文件删除失败。

");}```2. 使用Files类删除文件Java 7已添加了一个名为Files的类，其中添加了一些额外的文件操作方法。

你可以使用该类的delete()方法删除文件。

例如，要删除名为“test.txt”的文件，可以使用以下代码：```Path path = Paths.get("test.txt");try {Files.delete(path);System.out.println("文件删除成功！");} catch (IOException e) {System.out.println("文件删除失败。

");e.printStackTrace();}```3. 使用Apache Commons IO库删除文件Apache Commons IO库提供了许多在Java中处理文件和目录的有用方法。

你可以使用该库的FileUtils类删除文件。

例如，要删除名为“test.txt”的文件，可以使用以下代码：```File file = new File("test.txt");try {FileUtils.forceDelete(file);System.out.println("文件删除成功！");} catch (IOException e) {System.out.println("文件删除失败。

java清空文件内容在Java编程中，有时候我们需要对文件进行操作，其中一个常见的需求就是清空文件的内容。

在本文中，我将向大家介绍如何使用Java语言来实现清空文件内容的操作。

首先，我们需要使用Java中的File类来表示文件对象。

我们可以通过File类的构造方法来创建一个文件对象，然后通过该对象来进行文件操作。

接下来，我们需要使用FileWriter类来向文件中写入数据。

FileWriter类是用来写入字符流的，我们可以通过它来向文件中写入数据，从而实现清空文件内容的操作。

下面是一个示例代码，演示了如何使用Java语言来清空文件内容：```java。

import java.io.File;import java.io.FileWriter;import java.io.IOException;public class ClearFileContent {。

public static void main(String[] args) {。

File file = new File("test.txt");try {。

FileWriter writer = new FileWriter(file); writer.write(""); // 将文件内容清空。

writer.close();System.out.println("文件内容已清空");} catch (IOException e) {。

e.printStackTrace();}。

}。

}。

```。

在上面的示例代码中，我们首先创建了一个File对象来表示要操作的文件。

然后，我们创建了一个FileWriter对象，并调用它的write方法来将文件内容清空。

最后，记得关闭文件写入流，释放资源。

除了使用FileWriter类来清空文件内容外，我们还可以使用RandomAccessFile类来实现相同的功能。

Java递归遍历⽂件夹⽂件递归概述：以编程的⾓度来看，递归指的是⽅法定义中调⽤⽅法本⾝的现象。

递归解决问题的思路： 把⼀个复杂的问题层层转化为⼀个与原问题相似的规模较⼩的问题来求解； 递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算。

递归解决问题要找到两个内容：①递归出⼝：否则会出现内存溢出；②递归规则：与原问题相似的规模较⼩的问题。

问题：获取桌⾯⽂件夹中所有⽂件名。

1import java.io.File;2public class wenJian {3public static void main(String[] args) {4//根据给定的路径创建⼀个File对象,()为⽂件夹路径5 File srcFile=new File("C:\\Users\\Chen\\Desktop");6//调⽤⽅法7 getAllFilePath(srcFile);8 }910//定义⼀个⽅法，⽤于获取给定⽬录下的所有内容，参数为第1步创建的File对象11public static void getAllFilePath(File srcFile) {12//获取给定的File⽬录下所有的⽂件或者⽬录的File数组13 File[] fileArry=srcFile.listFiles();14//遍历该File数组，得到每⼀个File对象15if(fileArry!=null) {16//遍历该File数组，得到每⼀个File对象17for(File file:fileArry) {18//判断File对象是否是⽬录19if(file.isDirectory()) {20//是：递归调⽤21 getAllFilePath(file);22 }else {23//不是：获取绝对路径输出在控制台24//System.out.println(file.getAbsolutePath());25//获取⽬录或⽂件名(这⾥获取⽂件名)26 System.out.println(file.getName());27 }28 }29 }30 }31 }。

java 递归删除文件方法（最新版4篇）《java 递归删除文件方法》篇1在Java 中，递归是一种很有用的方法，可以用来解决许多问题。

以下是一个递归删除文件的方法示例：```javaimport java.io.File;import java.io.IOException;public class RecursiveFileDelete {public static void main(String[] args) {deleteFileRecursively("D:/test/");}public static void deleteFileRecursively(String filePath) {File file = new File(filePath);if (file.exists()) {if (file.isDirectory()) {for (File childFile : file.listFiles()) {deleteFileRecursively(childFile.getAbsolutePath());}} else {try {file.delete();} catch (IOException e) {e.printStackTrace();}}}}}```这个方法接受一个文件路径作为参数，并递归地删除指定路径下的所有文件和子目录。

《java 递归删除文件方法》篇2在Java 中，递归是一种非常有用的方法，它允许函数调用自身以实现特定的目标。

在处理文件和目录时，递归方法尤其有用。

这里是一个Java 递归删除文件的方法示例：```javaimport java.io.File;import java.io.IOException;public class RecursiveFileDeletion {public static void main(String[] args) {deleteFileRecursively(new File("path/to/file/or/directory"));}public static void deleteFileRecursively(File file) {if (file.isDirectory()) {String[] children = file.list();for (String child : children) {deleteFileRecursively(new File(file, child));}} else {try {file.delete();} catch (IOException e) {System.err.println("Error deleting file: " + e.getMessage());}}}}```这个示例中的`deleteFileRecursively` 方法接受一个`File` 对象作为参数，表示要删除的文件或目录。