Come eliminare una cartella con file utilizzando Java

Voglio creare ed eliminare una directory utilizzando Java, ma non funziona.

File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
    index.mkdir();
} else {
    index.delete();
    if (!index.exists()) {
        index.mkdir();
    }
}

Java non è in grado di eliminare cartelle con dati al suo interno. È necessario eliminare tutti i file prima di eliminare la cartella.

Usa qualcosa come:

String[]entries = index.list();
for(String s: entries){
    File currentFile = new File(index.getPath(),s);
    currentFile.delete();
}

Quindi dovresti essere in grado di eliminare la cartella utilizzando index.delete() Untested!

Solo una battuta.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Documentazione qui

Funziona, e anche se sembra inefficiente saltare il test della directory, non lo è: il test viene eseguito immediatamente in listFiles().

void deleteDir(File file) {
    File[] contents = file.listFiles();
    if (contents != null) {
        for (File f : contents) {
            deleteDir(f);
        }
    }
    file.delete();
}

Aggiorna, per evitare i seguenti link simbolici:

void deleteDir(File file) {
    File[] contents = file.listFiles();
    if (contents != null) {
        for (File f : contents) {
            if (! Files.isSymbolicLink(f.toPath())) {
                deleteDir(f);
            }
        }
    }
    file.delete();
}

Preferisco questa soluzione su java 8:

  Files.walk(pathToBeDeleted)
    .sorted(Comparator.reverseOrder())
    .map(Path::toFile)
    .forEach(File::delete);

Da questo sito: http://www.baeldung.com/java-delete-directory

In JDK 7 è possibile utilizzare Files.walkFileTree()e Files.deleteIfExists()per eliminare un albero di file. (Esempio: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )

In JDK 6 un modo possibile è usare FileUtils.deleteQuietly da Apache Commons che rimuoverà un file, una directory o una directory con file e sottodirectory.

Utilizzando Apache Commons-IO, segue una riga:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

Questo è (leggermente) più performante di FileUtils.deleteDirectory.

Come accennato, Java non è in grado di eliminare una cartella che contiene file, quindi elimina prima i file e poi la cartella.

Ecco un semplice esempio per farlo:

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

O:

FileUtils.forceDelete(new File(destination));

La mia versione ricorsiva di base, che funziona con versioni precedenti di JDK:

public static void deleteFile(File element) {
    if (element.isDirectory()) {
        for (File sub : element.listFiles()) {
            deleteFile(sub);
        }
    }
    element.delete();
}

Questa è la migliore soluzione per 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;
            }
        });
    }
}

Guava 21+ in soccorso. Utilizzare solo se non ci sono collegamenti simbolici che puntano fuori dalla directory da eliminare.

com.google.common.io.MoreFiles.deleteRecursively(
      file.toPath(),
      RecursiveDeleteOption.ALLOW_INSECURE
) ;

(Questa domanda è ben indicizzata da Google, quindi altre persone che usano Guava potrebbero essere felici di trovare questa risposta, anche se è ridondante con altre risposte altrove.)

Mi piace di più questa soluzione. Non utilizza la libreria di terze parti, invece utilizza NIO2 di 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;
        }
    });
}

Un'altra scelta è usare il org.springframework.util.FileSystemUtilsmetodo pertinente di Spring che cancellerà ricorsivamente tutto il contenuto della directory.

File directoryToDelete = new File(<your_directory_path_to_delete>);
FileSystemUtils.deleteRecursively(directoryToDelete);

Questo farà il lavoro!

In questo

index.delete();

            if (!index.exists())
               {
                   index.mkdir();
               }

stai chiamando

 if (!index.exists())
                   {
                       index.mkdir();
                   }

dopo

index.delete();

Ciò significa che stai creando di nuovo il file dopo aver eliminato File.delete () restituisce un valore booleano Quindi se vuoi controllare, fallo System.out.println(index.delete());se ottieni, truesignifica che il file è stato cancellato

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
               }




        }

dai commenti riportati di seguito, la risposta aggiornata è così

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

Se hai sottocartelle, troverai problemi con le risposte Cemron. quindi dovresti creare un metodo che funzioni in questo modo:

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

È possibile utilizzare FileUtils.deleteDirectory . JAVA non può eliminare le cartelle non vuote con File.delete () .

directry non può semplicemente eliminare se ha i file, quindi potrebbe essere necessario eliminare prima i file all'interno e poi la directory

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

È possibile effettuare chiamate ricorsive se esistono sottodirectory

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

possiamo usare la spring-coredipendenza;

boolean result = FileSystemUtils.deleteRecursively(file);

La maggior parte delle risposte (anche recenti) che fanno riferimento a classi JDK si basano su, File.delete()ma questa è un'API difettosa in quanto l'operazione potrebbe non riuscire silenziosamente.
La java.io.File.delete()documentazione del metodo afferma:

Si noti che la java.nio.file.Filesclasse definisce il deletemetodo per lanciare un IOExceptionquando un file non può essere cancellato. Ciò è utile per la segnalazione degli errori e per diagnosticare il motivo per cui un file non può essere eliminato.

In sostituzione, dovresti preferire Files.delete(Path p) che genera un IOExceptionmessaggio di errore.

Il codice effettivo potrebbe essere scritto come:

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

puoi provare come segue

  File dir = new File("path");
   if (dir.isDirectory())
   {
         dir.delete();
   }

Se sono presenti sottocartelle all'interno della cartella, potrebbe essere necessario eliminarle ricorsivamente.

private void deleteFileOrFolder(File file){
    try {
        for (File f : file.listFiles()) {
            f.delete();
            deleteFileOrFolder(f);
        }
    } catch (Exception e) {
        e.printStackTrace(System.err);
    }
}

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

    }

Funziona come un fascino. Sia per cartelle che per file. Salam :)

Rimuoverlo da un'altra parte

File index = new File("/home/Work/Indexer1");
if (!index.exists())
{
     index.mkdir();
     System.out.println("Dir Not present. Creating new one!");
}
index.delete();
System.out.println("File deleted successfully");

Alcune di queste risposte sembrano inutilmente lunghe:

if (directory.exists()) {
    for (File file : directory.listFiles()) {
        file.delete();
    }
    directory.delete();
}

Funziona anche per le sottodirectory.

Puoi usare questa funzione

public void delete()    
{   
    File f = new File("E://implementation1/");
    File[] files = f.listFiles();
    for (File file : files) {
        file.delete();
    }
}