Comment supprimer un dossier avec des fichiers en utilisant Java
Je souhaite créer et supprimer un répertoire à l'aide de Java, mais cela ne fonctionne pas.
File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
index.mkdir();
} else {
index.delete();
if (!index.exists()) {
index.mkdir();
}
}
Java ne peut pas supprimer les dossiers contenant des données. Vous devez supprimer tous les fichiers avant de supprimer le dossier.
Utilisez quelque chose comme:
String[]entries = index.list();
for(String s: entries){
File currentFile = new File(index.getPath(),s);
currentFile.delete();
}
Ensuite, vous devriez pouvoir supprimer le dossier en utilisant index.delete() Untested!
Juste un one-liner.
import org.Apache.commons.io.FileUtils;
FileUtils.deleteDirectory(new File(destination));
Documentation ici
Cela fonctionne, et bien qu'il semble inefficace d'ignorer le test de répertoire, ce n'est pas le cas: le test a lieu immédiatement dans listFiles().
void deleteDir(File file) {
File[] contents = file.listFiles();
if (contents != null) {
for (File f : contents) {
deleteDir(f);
}
}
file.delete();
}
Mise à jour, pour éviter les liens symboliques suivants:
void deleteDir(File file) {
File[] contents = file.listFiles();
if (contents != null) {
for (File f : contents) {
if (! Files.isSymbolicLink(f.toPath())) {
deleteDir(f);
}
}
}
file.delete();
}
Dans JDK 7, vous pouvez utiliser Files.walkFileTree() et Files.deleteIfExists() pour supprimer une arborescence de fichiers.
Dans JDK 6, un moyen possible consiste à utiliser FileUtils.deleteQuietly à partir d'Apache Commons, qui supprimera un fichier, un répertoire ou un répertoire avec des fichiers et des sous-répertoires.
À l’aide d’Apache Commons-IO, il s’agit d’une seule ligne:
import org.Apache.commons.io.FileUtils;
FileUtils.forceDelete(new File(destination));
C'est (légèrement) plus performant que FileUtils.deleteDirectory.
Je préfère cette solution sur Java 8:
Files.walk(pathToBeDeleted)
.sorted(Comparator.reverseOrder())
.map(Path::toFile)
.forEach(File::delete);
Depuis ce site: http://www.baeldung.com/Java-delete-directory
Ma version récursive de base, fonctionnant avec les anciennes versions de JDK:
public static void deleteFile(File element) {
if (element.isDirectory()) {
for (File sub : element.listFiles()) {
deleteFile(sub);
}
}
element.delete();
}
C'est la meilleure solution pour Java 7+:
public static void deleteDirectory(String directoryFilePath) throws IOException
{
Path directory = Paths.get(directoryFilePath);
if (Files.exists(directory))
{
Files.walkFileTree(directory, new SimpleFileVisitor<Path>()
{
@Override
public FileVisitResult visitFile(Path path, BasicFileAttributes basicFileAttributes) throws IOException
{
Files.delete(path);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path directory, IOException ioException) throws IOException
{
Files.delete(directory);
return FileVisitResult.CONTINUE;
}
});
}
}
J'aime le plus cette solution. Il n'utilise pas de bibliothèque tierce, mais NIO2 sur Java 7.
/**
* Deletes Folder with all of its content
*
* @param folder path to folder which should be deleted
*/
public static void deleteFolderAndItsContent(final Path folder) throws IOException {
Files.walkFileTree(folder, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
Files.delete(file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
if (exc != null) {
throw exc;
}
Files.delete(dir);
return FileVisitResult.CONTINUE;
}
});
}
Comme mentionné précédemment, Java ne peut pas supprimer un dossier contenant des fichiers. Par conséquent, supprimez d'abord les fichiers, puis le dossier.
Voici un exemple simple pour faire ceci:
import org.Apache.commons.io.FileUtils;
// First, remove files from into the folder
FileUtils.cleanDirectory(folder/path);
// Then, remove the folder
FileUtils.deleteDirectory(folder/path);
Ou:
FileUtils.forceDelete(new File(destination))
Guava 21+ à la rescousse. Utilisez-le uniquement s'il n'y a aucun lien symbolique pointant hors du répertoire à supprimer.
com.google.common.io.MoreFiles.deleteRecursively(
file.toPath(),
RecursiveDeleteOption.ALLOW_INSECURE
) ;
(Cette question est bien répertoriée par Google. Par conséquent, d'autres personnes utilisant Guava pourraient être heureuses de trouver cette réponse, même si elle est redondante avec d'autres réponses ailleurs.)
Dans ce
index.delete();
if (!index.exists())
{
index.mkdir();
}
vous appelez
if (!index.exists())
{
index.mkdir();
}
après
index.delete();
Cela signifie que vous créez à nouveau le fichier après la suppression de File.delete () renvoie une valeur booléenne. Ainsi, si vous voulez vérifier, faites System.out.println(index.delete()); si vous obtenez true puis cela signifie que le fichier est supprimé
File index = new File("/home/Work/Indexer1");
if (!index.exists())
{
index.mkdir();
}
else{
System.out.println(index.delete());//If you get true then file is deleted
if (!index.exists())
{
index.mkdir();// here you are creating again after deleting the file
}
}
de la commentaires donné ci-dessous, la réponse mise à jour est comme ceci
File f=new File("full_path");//full path like c:/home/ri
if(f.exists())
{
f.delete();
}
else
{
try {
//f.createNewFile();//this will create a file
f.mkdir();//this create a folder
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Vous pouvez utiliser FileUtils.deleteDirectory. Java ne peut pas supprimer les dossiers non vides avec File.delete ().
nous pouvons utiliser la dépendance spring-core;
boolean result = FileSystemUtils.deleteRecursively(file);
Si vous avez des sous-dossiers, vous rencontrerez des problèmes avec les réponses de Cemron. vous devriez donc créer une méthode qui fonctionne comme ceci:
private void deleteTempFile(File tempFile) {
try
{
if(tempFile.isDirectory()){
File[] entries = tempFile.listFiles();
for(File currentFile: entries){
deleteTempFile(currentFile);
}
tempFile.delete();
}else{
tempFile.delete();
}
getLogger().info("DELETED Temporal File: " + tempFile.getPath());
}
catch(Throwable t)
{
getLogger().error("Could not DELETE file: " + tempFile.getPath(), t);
}
}
le répertoire ne peut pas simplement être supprimé s'il contient les fichiers. Vous devrez peut-être d'abord supprimer les fichiers à l'intérieur, puis le répertoire.
public class DeleteFileFolder {
public DeleteFileFolder(String path) {
File file = new File(path);
if(file.exists())
{
do{
delete(file);
}while(file.exists());
}else
{
System.out.println("File or Folder not found : "+path);
}
}
private void delete(File file)
{
if(file.isDirectory())
{
String fileList[] = file.list();
if(fileList.length == 0)
{
System.out.println("Deleting Directory : "+file.getPath());
file.delete();
}else
{
int size = fileList.length;
for(int i = 0 ; i < size ; i++)
{
String fileName = fileList[i];
System.out.println("File path : "+file.getPath()+" and name :"+fileName);
String fullPath = file.getPath()+"/"+fileName;
File fileOrFolder = new File(fullPath);
System.out.println("Full Path :"+fileOrFolder.getPath());
delete(fileOrFolder);
}
}
}else
{
System.out.println("Deleting file : "+file.getPath());
file.delete();
}
}
Vous pouvez effectuer un appel récursif s'il existe des sous-répertoires
import Java.io.File;
class DeleteDir {
public static void main(String args[]) {
deleteDirectory(new File(args[0]));
}
static public boolean deleteDirectory(File path) {
if( path.exists() ) {
File[] files = path.listFiles();
for(int i=0; i<files.length; i++) {
if(files[i].isDirectory()) {
deleteDirectory(files[i]);
}
else {
files[i].delete();
}
}
}
return( path.delete() );
}
}
La plupart des réponses (même récentes) faisant référence aux classes JDK reposent sur File.delete() mais il s'agit d'une API défectueuse car l'opération peut échouer en silence.
La documentation de la méthode Java.io.File.delete() indique:
Notez que la classe
Java.nio.file.Filesdéfinit la méthodedeletepour lancer unIOExceptionlorsqu'un fichier ne peut pas être supprimé. Ceci est utile pour signaler des erreurs et diagnostiquer pourquoi un fichier ne peut pas être supprimé.
En remplacement, vous devriez préférer Files.delete(Path p) qui lance un IOException avec un message d'erreur.
Le code actuel pourrait être écrit tel que:
Path index = Paths.get("/home/Work/Indexer1");
if (!Files.exists(index)) {
index = Files.createDirectories(index);
} else {
Files.walk(index)
.sorted(Comparator.reverseOrder()) // as the file tree is traversed depth-first and that deleted dirs have to be empty
.forEach(t -> {
try {
Files.delete(t);
} catch (IOException e) {
// LOG the exception and potentially stop the processing
}
});
if (!Files.exists(index)) {
index = Files.createDirectories(index);
}
}
private void deleteFileOrFolder(File file){
try {
for (File f : file.listFiles()) {
f.delete();
deleteFileOrFolder(f);
}
} catch (Exception e) {
e.printStackTrace(System.err);
}
}
vous pouvez essayer comme suit
File dir = new File("path");
if (dir.isDirectory())
{
dir.delete();
}
S'il y a des sous-dossiers dans votre dossier, vous devrez peut-être les supprimer de manière récursive.
import org.Apache.commons.io.FileUtils;
List<String> directory = new ArrayList();
directory.add("test-output");
directory.add("Reports/executions");
directory.add("Reports/index.html");
directory.add("Reports/report.properties");
for(int count = 0 ; count < directory.size() ; count ++)
{
String destination = directory.get(count);
deleteDirectory(destination);
}
public void deleteDirectory(String path) {
File file = new File(path);
if(file.isDirectory()){
System.out.println("Deleting Directory :" + path);
try {
FileUtils.deleteDirectory(new File(path)); //deletes the whole folder
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
else {
System.out.println("Deleting File :" + path);
//it is a simple file. Proceed for deletion
file.delete();
}
}
Fonctionne comme un charme. Pour les dossiers et les fichiers. Salam :)