Java를 사용하여 파일이있는 폴더를 삭제하는 방법

Java를 사용하여 디렉토리를 만들고 삭제하고 싶지만 작동하지 않습니다.

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

Java는 데이터가있는 폴더를 삭제할 수 없습니다. 폴더를 삭제하기 전에 모든 파일을 삭제해야합니다.

다음과 같이 사용하십시오.

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

그런 다음 index.delete() Untested 를 사용하여 폴더를 삭제할 수 있어야합니다 !

한 줄로.

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

여기에 문서화

이것은 작동하며 디렉터리 테스트를 건너 뛰는 것은 비효율적으로 보이지만 그렇지 않습니다. 테스트는 listFiles().

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

다음 기호 링크를 방지하려면 업데이트하십시오.

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

Java 8에서이 솔루션을 선호합니다.

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

이 사이트에서 : http://www.baeldung.com/java-delete-directory

JDK 7에서는 Files.walkFileTree()및 Files.deleteIfExists()파일 트리를 삭제하는 데 사용할 수 있습니다 . (샘플 : http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )

JDK 6에서 가능한 한 가지 방법은 Apache Commons에서 FileUtils.deleteQuietly 를 사용 하여 파일, 디렉토리 또는 파일과 하위 디렉토리가있는 디렉토리를 제거하는 것입니다.

Apache Commons-IO를 사용하면 다음과 같습니다.

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

이것은 (약간) 더 성능이 좋습니다 FileUtils.deleteDirectory.

앞서 언급했듯이 Java는 파일이 포함 된 폴더를 삭제할 수 없으므로 먼저 파일을 삭제 한 다음 폴더를 삭제합니다.

다음은이를 수행하는 간단한 예입니다.

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

또는:

FileUtils.forceDelete(new File(destination));

JDK의 이전 버전으로 작업하는 기본 재귀 버전 :

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

다음을위한 최상의 솔루션입니다 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;
            }
        });
    }
}

구아바 21+가 구출됩니다. 삭제할 디렉토리를 가리키는 심볼릭 링크가없는 경우에만 사용하십시오.

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

(이 질문은 Google에서 색인이 잘 생성되어 있으므로 Guava를 사용하는 다른 사람들은 다른 답변과 중복되는 경우에도이 답변을 기꺼이 찾을 수 있습니다.)

이 솔루션이 가장 마음에 듭니다. 타사 라이브러리를 사용하지 않고 대신 Java 7의 NIO2 를 사용합니다 .

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

한 가지 더 선택은 org.springframework.util.FileSystemUtils디렉토리의 모든 내용을 재귀 적으로 삭제하는 Spring의 관련 메소드 를 사용 하는 것입니다.

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

그게 일을 할 것입니다!

이것에

index.delete();

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

당신은 전화하고 있습니다

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

후

index.delete();

즉, File.delete ()를 삭제 한 후 다시 파일을 생성하고 있음을 의미합니다. File.delete () 는 boolean 값을 반환합니다. 따라서 확인하고 싶다면 확인 System.out.println(index.delete());하면 true파일이 삭제되었음을 의미합니다.

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
               }




        }

으로부터 의견 아래, 업데이트 된 대답은 다음과 같이이다

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

하위 폴더가있는 경우 Cemron 답변에 문제가 있습니다. 따라서 다음과 같이 작동하는 메서드를 만들어야합니다.

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

FileUtils.deleteDirectory 를 사용할 수 있습니다 . JAVA는 File.delete () 사용 하여 비어 있지 않은 폴더를 삭제할 수 없습니다 .

directry는 파일이있는 경우 단순히 삭제할 수 없으므로 먼저 내부 파일을 삭제 한 다음 디렉토리를 삭제해야 할 수 있습니다.

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

하위 디렉토리가 있으면 재귀 호출을 할 수 있습니다.

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

spring-core의존성을 사용할 수 있습니다 .

boolean result = FileSystemUtils.deleteRecursively(file);

JDK 클래스를 참조하는 대부분의 답변 (심지어 최근까지)은 이에 의존 File.delete()하지만 작업이 조용히 실패 할 수 있으므로 결함이있는 API입니다. 방법 문서 상태 :
java.io.File.delete()

점을 유의 java.nio.file.Files클래스가 정의 delete을 던지는 방법 IOException파일이 삭제 될 수 없을 때를. 이는 오류보고 및 파일을 삭제할 수없는 이유를 진단하는 데 유용합니다.

대신 오류 메시지가 표시 Files.delete(Path p) 되는 것을 선호해야 IOException합니다.

실제 코드는 다음과 같이 작성할 수 있습니다.

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

다음과 같이 시도 할 수 있습니다.

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

폴더 안에 하위 폴더가있는 경우이를 재귀 적으로 삭제해야 할 수 있습니다.

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

    }

매력처럼 작동합니다. 폴더와 파일 모두. 살람 :)

다른 부분에서 제거

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

이러한 답변 중 일부는 불필요하게 길어 보입니다.

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

하위 디렉토리에서도 작동합니다.

이 기능을 사용할 수 있습니다

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