registro - Cómo eliminar una carpeta con archivos usando Java

eliminar un registro de un fichero en java

Question

Quiero crear y eliminar un directorio usando Java, pero no está funcionando.

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

Answer 1

Algunas de estas respuestas parecen innecesariamente largas:

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

Funciona también para subdirectorios.

Answer 2

Crear directorio -

File directory = new File("D:/Java/Example");
boolean isCreated = directory.mkdir();

Eliminar directorio -

Consulte este recurso para obtener una explicación detallada: elimine el directorio .

Answer 3

Eliminarlo de la parte else

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

Answer 4

En JDK 7 puede usar Files.walkFileTree() y Files.deleteIfExists() para eliminar un árbol de archivos.

En JDK 6, una forma posible es utilizar FileUtils.deleteQuietly de Apache Commons, que eliminará un archivo, un directorio o un directorio con archivos y subdirectorios.

Answer 5

En esto

index.delete();

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

estas llamando

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

después

index.delete();

Esto significa que está creando el archivo nuevamente después de eliminar File.delete() devuelve un valor booleano. Así que si desea verificar, haga System.out.println(index.delete()); si te haces true , significa que el archivo se ha eliminado

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 los comments figuran a continuación, la respuesta actualizada es como esta

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

Answer 6

Esta es la mejor solución para 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;
            }
        });
    }
}

Answer 7

Esto funciona, y si bien parece ineficaz omitir la prueba de directorio, no lo es: la prueba ocurre de inmediato en listFiles() .

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

Actualización, para evitar seguir enlaces simbólicos:

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

Answer 8

Guava 21+ al rescate. Úselo solo si no hay enlaces simbólicos que indiquen fuera del directorio para eliminar.

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

(Esta pregunta está bien indexada por Google, por lo que otras personas que usan Guava podrían estar felices de encontrar esta respuesta, incluso si es redundante con otras respuestas en otros lugares).

Answer 9

Java no puede eliminar carpetas con datos en él. Tienes que borrar todos los archivos antes de eliminar la carpeta.

Use algo como:

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

¡Entonces debería poder eliminar la carpeta usando index.delete() probado!

Answer 10

La mayoría de las respuestas (incluso recientes) que hacen referencia a las clases de JDK se basan en File.delete() pero esa es una API defectuosa, ya que la operación puede fallar de manera silenciosa.
La documentación del método java.io.File.delete() indica:

Tenga en cuenta que la clase java.nio.file.Files define el método de delete para lanzar una IOException cuando no se puede eliminar un archivo. Esto es útil para reportar errores y diagnosticar por qué un archivo no se puede eliminar.

Como reemplazo, debe favorecer a Files.delete(Path p) que arroja una IOException con un mensaje de error.

El código real podría escribirse como:

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

Answer 11

Me gusta más esta solución. No utiliza una biblioteca de terceros, en su lugar usa NIO2 de 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;
        }
    });
}

Answer 12

Mi versión recursiva básica, que trabaja con versiones anteriores de JDK:

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

Answer 13

Prefiero esta solución en java 8:

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

Desde este sitio: http://www.baeldung.com/java-delete-directory

Answer 14

Puede hacer una llamada recursiva si existen subdirectorios

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

Answer 15

Puedes usar esta función

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

Answer 16

Si tiene subcarpetas, encontrará problemas con las respuestas de Cemron. entonces deberías crear un método que funcione así:

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

Answer 17

Solo un trazador de líneas.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

Documentación here

Answer 18

Utilizando Apache Commons-IO, está siguiendo una línea:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

Esto es (un poco) más FileUtils.deleteDirectory que FileUtils.deleteDirectory .

Answer 19

directry no puede simplemente eliminar si tiene los archivos, por lo que es posible que deba eliminar los archivos dentro primero y luego directorio

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

Answer 20

podemos usar la dependencia spring-core ;

boolean result = FileSystemUtils.deleteRecursively(file);

Answer 21

puedes intentarlo de la siguiente manera

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

Si hay subcarpetas dentro de su carpeta, es posible que deba eliminarlas recursivamente.

Answer 22

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

    }

Funciona de maravilla . Para ambas carpetas y archivos. Salam :)

Answer 23

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