Quiero crear y eliminar un directorio usando Java, pero no funciona.
File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
index.mkdir();
} else {
index.delete();
if (!index.exists()) {
index.mkdir();
}
}
Quiero crear y eliminar un directorio usando Java, pero no funciona.
File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
index.mkdir();
} else {
index.delete();
if (!index.exists()) {
index.mkdir();
}
}
Respuestas:
Java no puede eliminar carpetas con datos. Debe eliminar todos los archivos antes de eliminar la carpeta.
Usa algo como:
String[]entries = index.list();
for(String s: entries){
File currentFile = new File(index.getPath(),s);
currentFile.delete();
}
¡Entonces deberías poder eliminar la carpeta usando Sin index.delete()
probar!
FileUtils.deleteDirectory
como dijo @Francesco Menzani.
if (!index.delete()) {...}
. Luego, si el índice es un enlace simbólico, se elimina independientemente de si parece que tiene contenido.
entries
es nulo.
Solo una frase.
import org.apache.commons.io.FileUtils;
FileUtils.deleteDirectory(new File(destination));
Documentación aquí
Esto funciona, y aunque parece ineficaz omitir la prueba del 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();
}
Actualizar, 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();
}
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
Files.walk()
, que se indica explícitamente en los documentos de la API. Sé que si no cierra la secuencia devuelta por, Files.list()
por ejemplo, puede quedarse sin identificadores y el programa se bloqueará. Consulte, por ejemplo, stackoverflow.com/q/36990053/421049 y stackoverflow.com/q/26997240/421049 .
En JDK 7, puede usar Files.walkFileTree()
y Files.deleteIfExists()
para eliminar un árbol de archivos. (Ejemplo: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )
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.
Usando Apache Commons-IO, sigue una línea:
import org.apache.commons.io.FileUtils;
FileUtils.forceDelete(new File(destination));
Esto es (ligeramente) más eficaz que FileUtils.deleteDirectory
.
Como se mencionó, Java no puede eliminar una carpeta que contiene archivos, así que primero elimine los archivos y luego la carpeta.
Aquí hay un ejemplo simple para hacer esto:
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));
Mi versión recursiva básica, trabajando con versiones anteriores de JDK:
public static void deleteFile(File element) {
if (element.isDirectory()) {
for (File sub : element.listFiles()) {
deleteFile(sub);
}
}
element.delete();
}
listFiles()
devuelve un valor nulo, en lugar de llamar isDirectory()
.
Ésta 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;
}
});
}
}
Guava 21+ al rescate. Úselo solo si no hay enlaces simbólicos que señalen 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 usen Guava podrían estar felices de encontrar esta respuesta, incluso si es redundante con otras respuestas en otros lugares).
Me gusta más esta solución. No utiliza una biblioteca de terceros, sino que utiliza 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;
}
});
}
Una opción más es utilizar el org.springframework.util.FileSystemUtils
método relevante de Spring, que eliminará de forma recursiva todo el contenido del directorio.
File directoryToDelete = new File(<your_directory_path_to_delete>);
FileSystemUtils.deleteRecursively(directoryToDelete);
¡Eso hará el trabajo!
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. Por lo tanto, si desea verificarlo, System.out.println(index.delete());
si lo obtiene true
, esto significa que el archivo se eliminó
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 comentarios que se dan a continuación, la respuesta actualizada es así
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();
}
}
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);
}
}
Puede utilizar FileUtils.deleteDirectory . JAVA no puede eliminar las carpetas no vacías con File.delete () .
directry no puede simplemente eliminar si tiene los archivos, por lo que es posible que primero deba eliminar los archivos internos y luego el 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();
}
}
Puede realizar llamadas recursivas 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() );
}
}
podemos usar la spring-core
dependencia;
boolean result = FileSystemUtils.deleteRecursively(file);
La mayoría de las respuestas (incluso recientes) que hacen referencia a clases de JDK se basan en, File.delete()
pero esa es una API defectuosa ya que la operación puede fallar silenciosamente.
La java.io.File.delete()
documentación del método dice:
Tenga en cuenta que la
java.nio.file.Files
clase define eldelete
método para lanzar unIOException
archivo cuando no se puede eliminar. Esto es útil para informar errores y diagnosticar por qué no se puede eliminar un archivo.
Como reemplazo, debe favorecer Files.delete(Path p)
que arroje un IOException
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);
}
}
puedes intentar lo siguiente
File dir = new File("path");
if (dir.isDirectory())
{
dir.delete();
}
Si hay subcarpetas dentro de su carpeta, es posible que deba eliminarlas de forma recursiva.
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();
}
}
Funciona de maravilla . Tanto para carpetas como para archivos. Salam :)
Eliminarlo de otra 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");
Algunas de estas respuestas parecen innecesariamente largas:
if (directory.exists()) {
for (File file : directory.listFiles()) {
file.delete();
}
directory.delete();
}
También funciona para subdirectorios.
Puedes usar esta función
public void delete()
{
File f = new File("E://implementation1/");
File[] files = f.listFiles();
for (File file : files) {
file.delete();
}
}