Comment supprimer un dossier et son contenu?
Je souhaite que les utilisateurs de mon application puissent supprimer le dossier DCIM (situé sur la carte SD et contenant des sous-dossiers).
Est-ce possible, si oui, comment?
Laissez-moi vous dire d’abord que vous ne pouvez pas supprimer le dossier DCIM car il s’agit d’un dossier système. Lorsque vous le supprimez manuellement sur le téléphone, le contenu de ce dossier sera supprimé, mais pas le dossier DCIM. Vous pouvez supprimer son contenu en utilisant la méthode ci-dessous:
Mis à jour selon les commentaires
File dir = new File(Environment.getExternalStorageDirectory()+"Dir_name_here");
if (dir.isDirectory())
{
String[] children = dir.list();
for (int i = 0; i < children.length; i++)
{
new File(dir, children[i]).delete();
}
}
Vous pouvez supprimer des fichiers et des dossiers de manière récursive comme ceci:
void deleteRecursive(File fileOrDirectory) {
if (fileOrDirectory.isDirectory())
for (File child : fileOrDirectory.listFiles())
deleteRecursive(child);
fileOrDirectory.delete();
}
Nous pouvons utiliser les arguments de la ligne de commande pour supprimer un dossier complet et son contenu.
public static void deleteFiles(String path) {
File file = new File(path);
if (file.exists()) {
String deleteCmd = "rm -r " + path;
Runtime runtime = Runtime.getRuntime();
try {
runtime.exec(deleteCmd);
} catch (IOException e) { }
}
}
Exemple d'utilisation du code ci-dessus:
deleteFiles("/sdcard/uploads/");
Votre approche est correcte pour un dossier contenant uniquement des fichiers, mais si vous recherchez un scénario contenant également des sous-dossiers, une récursion est nécessaire.
Vous devez également capturer la valeur de retour du retour pour vous assurer que vous êtes autorisé à supprimer le fichier.
et inclure
<uses-permission Android:name="Android.permission.WRITE_EXTERNAL_STORAGE" />
dans votre manifeste
void DeleteRecursive(File dir)
{
Log.d("DeleteRecursive", "DELETEPREVIOUS TOP" + dir.getPath());
if (dir.isDirectory())
{
String[] children = dir.list();
for (int i = 0; i < children.length; i++)
{
File temp = new File(dir, children[i]);
if (temp.isDirectory())
{
Log.d("DeleteRecursive", "Recursive Call" + temp.getPath());
DeleteRecursive(temp);
}
else
{
Log.d("DeleteRecursive", "Delete File" + temp.getPath());
boolean b = temp.delete();
if (b == false)
{
Log.d("DeleteRecursive", "DELETE FAIL");
}
}
}
}
dir.delete();
}
utilisez la méthode ci-dessous pour supprimer tout le répertoire principal contenant les fichiers et son sous-répertoire. Après avoir appelé à nouveau cette méthode, appelez le répertoire delete () de votre répertoire principal.
// For to Delete the directory inside list of files and inner Directory
public static boolean deleteDir(File dir) {
if (dir.isDirectory()) {
String[] children = dir.list();
for (int i=0; i<children.length; i++) {
boolean success = deleteDir(new File(dir, children[i]));
if (!success) {
return false;
}
}
}
// The directory is now empty so delete it
return dir.delete();
}
Dans Kotlin, vous pouvez utiliser l'extension deleteRecursively() du package kotlin.io
val someDir = File("/path/to/dir")
someDir.deleteRecursively()
Il y a beaucoup de réponses, mais j'ai décidé d'ajouter les miennes, car c'est un peu différent. C'est basé sur OOP;)
J'ai créé la classe DirectoryCleaner , qui m'aide chaque fois que je dois nettoyer un répertoire.
public class DirectoryCleaner {
private final File mFile;
public DirectoryCleaner(File file) {
mFile = file;
}
public void clean() {
if (null == mFile || !mFile.exists() || !mFile.isDirectory()) return;
for (File file : mFile.listFiles()) {
delete(file);
}
}
private void delete(File file) {
if (file.isDirectory()) {
for (File child : file.listFiles()) {
delete(child);
}
}
file.delete();
}
}
Il peut être utilisé pour résoudre ce problème de la manière suivante:
File dir = new File(Environment.getExternalStorageDirectory(), "your_directory_name");
new DirectoryCleaner(dir).clean();
dir.delete();
Si vous n'avez pas besoin de supprimer des éléments de manière récursive, vous pouvez essayer quelque chose comme ceci:
File file = new File(context.getExternalFilesDir(null), "");
if (file != null && file.isDirectory()) {
File[] files = file.listFiles();
if(files != null) {
for(File f : files) {
f.delete();
}
}
}
voir Android.os.FileUtils, c'est masqué sur l'API 21
public static boolean deleteContents(File dir) {
File[] files = dir.listFiles();
boolean success = true;
if (files != null) {
for (File file : files) {
if (file.isDirectory()) {
success &= deleteContents(file);
}
if (!file.delete()) {
Log.w("Failed to delete " + file);
success = false;
}
}
}
return success;
}
public static void deleteDirectory( File dir )
{
if ( dir.isDirectory() )
{
String [] children = dir.list();
for ( int i = 0 ; i < children.length ; i ++ )
{
File child = new File( dir , children[i] );
if(child.isDirectory()){
deleteDirectory( child );
child.delete();
}else{
child.delete();
}
}
dir.delete();
}
}
C'est ce que je fais ... (laconique et testé)
...
deleteDir(new File(dir_to_be_deleted));
...
// delete directory and contents
void deleteDir(File file) {
if (file.isDirectory())
for (String child : file.list())
deleteDir(new File(file, child));
file.delete(); // delete child file or empty directory
}
private static void deleteRecursive(File dir)
{
//Log.d("DeleteRecursive", "DELETEPREVIOUS TOP" + dir.getPath());
if (dir.isDirectory())
{
String[] children = dir.list();
for (int i = 0; i < children.length; i++)
{
File temp = new File(dir, children[i]);
deleteRecursive(temp);
}
}
if (dir.delete() == false)
{
Log.d("DeleteRecursive", "DELETE FAIL");
}
}
Un moyen simple de supprimer tous les fichiers du répertoire:
C'est une fonction générique pour supprimer toutes les images du répertoire en appelant uniquement
deleteAllImageFile (context);
public static void deleteAllFile(Context context) {
File directory = context.getExternalFilesDir(null);
if (directory.isDirectory()) {
for (String fileName: file.list()) {
new File(file,fileName).delete();
}
}
}
Selon le documentation :
Si ce chemin d'accès abstrait ne désigne pas un répertoire, cette méthode renvoie null.
Donc, vous devriez vérifier si listFiles est null et ne continuer que si ce n'est pas
boolean deleteDirectory(File path) {
if(path.exists()) {
File[] files = path.listFiles();
if (files == null) {
return false;
}
for (File file : files) {
if (file.isDirectory()) {
deleteDirectory(file);
} else {
boolean wasSuccessful = file.delete();
if (wasSuccessful) {
Log.i("Deleted ", "successfully");
}
}
}
}
return(path.delete());
}
Voici une implémentation non récursive, juste pour le fun:
/**
* Deletes the given folder and all its files / subfolders.
* Is not implemented in a recursive way. The "Recursively" in the name stems from the filesystem command
* @param root The folder to delete recursively
*/
public static void deleteRecursively(final File root) {
LinkedList<File> deletionQueue = new LinkedList<>();
deletionQueue.add(root);
while(!deletionQueue.isEmpty()) {
final File toDelete = deletionQueue.removeFirst();
final File[] children = toDelete.listFiles();
if(children == null || children.length == 0) {
// This is either a file or an empty directory -> deletion possible
toDelete.delete();
} else {
// Add the children before the folder because they have to be deleted first
deletionQueue.addAll(Arrays.asList(children));
// Add the folder again because we can't delete it yet.
deletionQueue.addLast(toDelete);
}
}
}
Code le plus sûr que je connaisse:
private boolean recursiveRemove(File file) {
if(file == null || !file.exists()) {
return false;
}
if(file.isDirectory()) {
File[] list = file.listFiles();
if(list != null) {
for(File item : list) {
recursiveRemove(item);
}
}
}
if(file.exists()) {
file.delete();
}
return !file.exists();
}
Vérifie que le fichier existe, gère les valeurs NULL, vérifie que le répertoire a été réellement supprimé
Vous ne pouvez pas supprimer le répertoire s'il contient des sous-répertoires ou des fichiers en Java. Essayez cette solution simple à deux lignes. Cela supprimera le répertoire et les concours à l'intérieur du répertoire.
File dirName = new File("directory path");
FileUtils.deleteDirectory(dirName);
Ajouter cette ligne dans le fichier Gradle et synchroniser le projet
compile 'org.Apache.commons:commons-io:1.3.2'
//To delete all the files of a specific folder & subfolder
public static void deleteFiles(File directory, Context c) {
try {
for (File file : directory.listFiles()) {
if (file.isFile()) {
final ContentResolver contentResolver = c.getContentResolver();
String canonicalPath;
try {
canonicalPath = file.getCanonicalPath();
} catch (IOException e) {
canonicalPath = file.getAbsolutePath();
}
final Uri uri = MediaStore.Files.getContentUri("external");
final int result = contentResolver.delete(uri,
MediaStore.Files.FileColumns.DATA + "=?", new String[]{canonicalPath});
if (result == 0) {
final String absolutePath = file.getAbsolutePath();
if (!absolutePath.equals(canonicalPath)) {
contentResolver.delete(uri,
MediaStore.Files.FileColumns.DATA + "=?", new String[]{absolutePath});
}
}
if (file.exists()) {
file.delete();
if (file.exists()) {
try {
file.getCanonicalFile().delete();
} catch (IOException e) {
e.printStackTrace();
}
if (file.exists()) {
c.deleteFile(file.getName());
}
}
}
} else
deleteFiles(file, c);
}
} catch (Exception e) {
}
}
voici votre solution, elle actualisera également la galerie.
Version courte de koltin
fun File.deleteDirectory(): Boolean {
return if (exists()) {
listFiles()?.forEach {
if (it.isDirectory) {
it.deleteDirectory()
} else {
it.delete()
}
}
delete()
} else false
}
Encore une autre façon (moderne) de le résoudre.
public class FileUtils {
public static void delete(File fileOrDirectory) {
if(fileOrDirectory != null && fileOrDirectory.exists()) {
if(fileOrDirectory.isDirectory() && fileOrDirectory.listFiles() != null) {
Arrays.stream(fileOrDirectory.listFiles())
.forEach(FileUtils::delete);
}
fileOrDirectory.delete();
}
}
}
Sur Android depuis l'API 26
public class FileUtils {
public static void delete(File fileOrDirectory) {
if(fileOrDirectory != null) {
delete(fileOrDirectory.toPath());
}
}
public static void delete(Path path) {
try {
if(Files.exists(path)) {
Files.walk(path)
.sorted(Comparator.reverseOrder())
.map(Path::toFile)
// .peek(System.out::println)
.forEach(File::delete);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Supprimer le dossier et tout ce qu'il contient à la souris en un clic:
my_button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
File folder_path = new File(Environment.getExternalStorageDirectory() + "/your_folder_name/");
if (file.exists()) {
String deleteCmd = "rm -r " + folder_path;
Runtime runtime = Runtime.getRuntime();
try {
runtime.exec(deleteCmd);
} catch (IOException ignored) {
}
}
}
});
J'ai mis celui-ci bien que son rythme supprime un dossier avec n'importe quelle structure de répertoires.
public int removeDirectory(final File folder) {
if(folder.isDirectory() == true) {
File[] folderContents = folder.listFiles();
int deletedFiles = 0;
if(folderContents.length == 0) {
if(folder.delete()) {
deletedFiles++;
return deletedFiles;
}
}
else if(folderContents.length > 0) {
do {
File lastFolder = folder;
File[] lastFolderContents = lastFolder.listFiles();
//This while loop finds the deepest path that does not contain any other folders
do {
for(File file : lastFolderContents) {
if(file.isDirectory()) {
lastFolder = file;
lastFolderContents = file.listFiles();
break;
}
else {
if(file.delete()) {
deletedFiles++;
}
else {
break;
}
}//End if(file.isDirectory())
}//End for(File file : folderContents)
} while(lastFolder.delete() == false);
deletedFiles++;
if(folder.exists() == false) {return deletedFiles;}
} while(folder.exists());
}
}
else {
return -1;
}
return 0;
}
J'espère que cela t'aides.