Comment supprimer un dossier complet et le contenu?
je veux que les utilisateurs de mon application puissent supprimer le dossier DCIM (qui est situé sur la carte SD et contient des sous-dossiers).
est-ce possible, si oui comment?
20 réponses
laissez-moi vous dire d'abord que vous ne pouvez pas supprimer le dossier DCIM parce qu'il s'agit d'un dossier système. Comme vous le supprimez manuellement sur le téléphone, il supprimera le contenu de ce dossier, mais pas le dossier DCIM. Vous pouvez supprimer son contenu en utilisant la méthode ci-dessous:
mise à Jour que par 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 façon 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 ligne de commande pour supprimer un dossier entier 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 décente pour un dossier qui ne contient que des fichiers, mais si vous recherchez un scénario qui contient aussi des sous-dossiers, alors la récursion est nécessaire
vous devez également saisir la valeur de retour de la déclaration pour vous assurer que vous êtes autorisé à supprimer le fichier
et comprend
<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 qui contient des fichiers et son sous-répertoire. Après avoir appelé cette méthode, appelez à nouveau 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();
}
Il y a beaucoup de réponses, mais j'ai décidé d'ajouter mon propre, parce que c'est un peu différent. Il est basé sur la programmation orientée objet ;)
j'ai créé la classe DirectoryCleaner , qui m'aide chaque fois que j'ai besoin de 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 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 choses récursivement, 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();
}
}
}
dans Kotlin vous pouvez utiliser deleteRecursively() extension de kotlin.io paquet
val someDir = File("/path/to/dir")
someDir.deleteRecursively()
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();
}
}
voir android.OS.FileUtils, c'est hide sur 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;
}
C'est ce que je fais... cents cinquante et une million neuf cent vingt mille neuf cent vingt"
...
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");
}
}
simple façon de supprimer tous les fichiers du répertoire:
il s'agit de la fonction générique pour supprimer toutes les images du répertoire en appelant seulement
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();
}
}
}
Voici une implémentation non-récursive, juste pour le plaisir:
/**
* 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 nulls, vérifie que le répertoire a été supprimé.""
j'ai mis celui-ci à travers ses' pas il supprime un dossier avec n'importe quelle structure de répertoire.
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;
}
Espérons que cette aide.
Vous ne pouvez pas supprimer le répertoire s'il a des sous-répertoires ou des fichiers en Java. Essayez cette solution simple en 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 gradle file 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 il rafraîchira aussi la galerie.
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 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 qui s'y trouve sur le bouton cliquer :
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) {
}
}
}
});