Quero criar e excluir um diretório usando Java, mas não está funcionando.
File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
index.mkdir();
} else {
index.delete();
if (!index.exists()) {
index.mkdir();
}
}
Quero criar e excluir um diretório usando Java, mas não está funcionando.
File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
index.mkdir();
} else {
index.delete();
if (!index.exists()) {
index.mkdir();
}
}
Respostas:
Java não é capaz de excluir pastas com dados. Você deve excluir todos os arquivos antes de excluir a pasta.
Use algo como:
String[]entries = index.list();
for(String s: entries){
File currentFile = new File(index.getPath(),s);
currentFile.delete();
}
Então você poderá excluir a pasta usando Não index.delete()
testado!
FileUtils.deleteDirectory
como disse @Francesco Menzani.
if (!index.delete()) {...}
. Então, se o índice for um link simbólico, ele será excluído independentemente de parecer que tem conteúdo.
entries
é nulo.
Apenas uma linha.
import org.apache.commons.io.FileUtils;
FileUtils.deleteDirectory(new File(destination));
Documentação aqui
Isso funciona e, embora pareça ineficiente pular o teste de diretório, não é: o teste acontece imediatamente em listFiles()
.
void deleteDir(File file) {
File[] contents = file.listFiles();
if (contents != null) {
for (File f : contents) {
deleteDir(f);
}
}
file.delete();
}
Atualizar, para evitar seguir links 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();
}
Eu prefiro esta solução em java 8:
Files.walk(pathToBeDeleted)
.sorted(Comparator.reverseOrder())
.map(Path::toFile)
.forEach(File::delete);
Deste site: http://www.baeldung.com/java-delete-directory
Files.walk()
, o que é explicitamente indicado nos documentos da API. Eu sei que se você não fechar o stream retornado por, Files.list()
por exemplo, você pode ficar sem alças e o programa irá travar. Consulte, por exemplo, stackoverflow.com/q/36990053/421049 e stackoverflow.com/q/26997240/421049 .
No JDK 7 você pode usar Files.walkFileTree()
e Files.deleteIfExists()
deletar uma árvore de arquivos. (Exemplo: http://fahdshariff.blogspot.ru/2011/08/java-7-deleting-directory-by-walking.html )
No JDK 6, uma maneira possível é usar FileUtils.deleteQuietly do Apache Commons, que removerá um arquivo, um diretório ou um diretório com arquivos e subdiretórios.
Usando o Apache Commons-IO, segue uma linha:
import org.apache.commons.io.FileUtils;
FileUtils.forceDelete(new File(destination));
Este é (ligeiramente) mais desempenho do que FileUtils.deleteDirectory
.
Como mencionado, o Java não é capaz de excluir uma pasta que contém arquivos, portanto, primeiro exclua os arquivos e depois a pasta.
Aqui está um exemplo simples para fazer isso:
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));
Minha versão recursiva básica, trabalhando com versões mais antigas do JDK:
public static void deleteFile(File element) {
if (element.isDirectory()) {
for (File sub : element.listFiles()) {
deleteFile(sub);
}
}
element.delete();
}
listFiles()
retorna nulo, em vez de chamar isDirectory()
.
Esta é a melhor solução 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;
}
});
}
}
Goiaba 21+ para o resgate. Use apenas se não houver links simbólicos apontando para fora do diretório para exclusão.
com.google.common.io.MoreFiles.deleteRecursively(
file.toPath(),
RecursiveDeleteOption.ALLOW_INSECURE
) ;
(Esta pergunta foi bem indexada pelo Google, então outras pessoas que usem Guava podem ficar felizes em encontrar esta resposta, mesmo que seja redundante com outras respostas em outros lugares.)
Gosto mais desta solução. Não usa biblioteca de terceiros, em vez disso 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;
}
});
}
Outra opção é usar o org.springframework.util.FileSystemUtils
método relevante do Spring, que excluirá recursivamente todo o conteúdo do diretório.
File directoryToDelete = new File(<your_directory_path_to_delete>);
FileSystemUtils.deleteRecursively(directoryToDelete);
Isso fará o trabalho!
Nisso
index.delete();
if (!index.exists())
{
index.mkdir();
}
você está ligando
if (!index.exists())
{
index.mkdir();
}
depois de
index.delete();
Isso significa que você está criando o arquivo novamente após a exclusão de
File.delete () retorna um valor booleano. Então, se você deseja verificar System.out.println(index.delete());
se obtiver true
, isso significa que o arquivo foi excluído
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
}
}
a partir dos comentários dados abaixo, a resposta atualizada é assim
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 você tiver subpastas, encontrará problemas com as respostas do Cemron. então você deve criar um método que funcione assim:
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);
}
}
Você pode usar FileUtils.deleteDirectory . JAVA não pode excluir as pastas não vazias com File.delete () .
O diretório não pode simplesmente deletar se ele tiver os arquivos, então você pode precisar deletar os arquivos dentro primeiro e depois o diretório
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();
}
}
Você pode fazer chamadas recursivas se houver subdiretórios
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 a spring-core
dependência;
boolean result = FileSystemUtils.deleteRecursively(file);
A maioria das respostas (mesmo recentes) que fazem referência a classes JDK dependem, File.delete()
mas essa é uma API falha, pois a operação pode falhar silenciosamente.
A java.io.File.delete()
documentação do método afirma:
Observe que a
java.nio.file.Files
classe define odelete
método para lançar umIOException
quando um arquivo não pode ser excluído. Isso é útil para relatórios de erros e para diagnosticar porque um arquivo não pode ser excluído.
Como substituto, você deve favorecer Files.delete(Path p)
que lance umIOException
com uma mensagem de erro.
O código real pode ser escrito 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);
}
}
você pode tentar o seguinte
File dir = new File("path");
if (dir.isDirectory())
{
dir.delete();
}
Se houver subpastas dentro da sua pasta, pode ser necessário excluí-las recursivamente.
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 como um encanto . Para pastas e arquivos. Salam :)
Remova-o de outra 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");
Algumas dessas respostas parecem desnecessariamente longas:
if (directory.exists()) {
for (File file : directory.listFiles()) {
file.delete();
}
directory.delete();
}
Funciona para subdiretórios também.
Você pode usar esta função
public void delete()
{
File f = new File("E://implementation1/");
File[] files = f.listFiles();
for (File file : files) {
file.delete();
}
}