Comment puis-je obtenir la taille d'un dossier sur une carte SD dans Android?

Est-il possible d'obtenir facilement la taille d'un dossier sur la carte SD? J'utilise un dossier pour la mise en cache d'images et je souhaite présenter la taille totale de toutes les images mises en cache. Existe-t-il un moyen d'éviter d'itérer sur chaque fichier? Ils résident tous dans le même dossier?

  • Comment convertir une chaîne en long
  • Comment puis-je obtenir un fichier apk à partir d'un appareil Android?
  • Comment mettre à jour AndroidManifest.XML dans resources.arsc à l'aide de l'outil aapt pour Android utilisant le terminal
  • SetRadius on Circle donne une mauvaise expérience utilisateur dans Google Maps
  • Quels appareils Android prennent en charge les jni?
  • Android: SQLite - insertWithOnConflict
  • NullPointerException dans handleOnGetSentenceSuggestionsMultiple (SpellCheckerSession)
  • Comment fonctionnent les applications Android "app lock"?
  • Utilisation de Scala avec Gradle pour le projet Android
  • Combien Java aurais-je appris avant d'essayer la programmation Android?
  • OnBind () n'est jamais appelé dans un service
  • Erreur "android.database.sqlite.SQLiteException: no table table" dans de rares cas
  • 9 Solutions collect form web for “Comment puis-je obtenir la taille d'un dossier sur une carte SD dans Android?”

    Passez simplement par tous les fichiers et résume la longueur de ceux-ci:

    /** * Return the size of a directory in bytes */ private static long dirSize(File dir) { if (dir.exists()) { long result = 0; File[] fileList = dir.listFiles(); for(int i = 0; i < fileList.length; i++) { // Recursive call if it's a directory if(fileList[i].isDirectory()) { result += dirSize(fileList [i]); } else { // Sum the file size in bytes result += fileList[i].length(); } } return result; // return the file size } return 0; } 

    REMARQUE: Fonction écrite à la main pour qu'il ne puisse pas compiler!

    EDITÉE: appel récursif corrigé.

    EDITED: dirList.length a changé en fileList.length.

    Voici un code qui évite la récursivité, et calcule aussi la taille physique au lieu de la taille logique:

      public static long getFileSize(final File file) { if(file==null||!file.exists()) return 0; if(!file.isDirectory()) return file.length(); final List<File> dirs=new LinkedList<File>(); dirs.add(file); long result=0; while(!dirs.isEmpty()) { final File dir=dirs.remove(0); if(!dir.exists()) continue; final File[] listFiles=dir.listFiles(); if(listFiles==null||listFiles.length==0) continue; for(final File child : listFiles) { result+=child.length(); if(child.isDirectory()) dirs.add(child); } } return result; } } 
     /** * Try this one for better performance * Mehran * Return the size of a directory in bytes **/ private static long dirSize(File dir) { long result = 0; Stack<File> dirlist= new Stack<File>(); dirlist.clear(); dirlist.push(dir); while(!dirlist.isEmpty()) { File dirCurrent = dirlist.pop(); File[] fileList = dirCurrent.listFiles(); for(File f: fileList){ if(f.isDirectory()) dirlist.push(f); else result += f.length(); } } return result; } 

    Vous devriez utiliser ce code:

     public static long getFolderSize(File f) { long size = 0; if (f.isDirectory()) { for (File file : f.listFiles()) { size += getFolderSize(file); } } else { size=f.length(); } return size; } 

    La façon de #Moss a raison. C'est mon code pour ceux qui souhaitent changer les octets en format lisible par l'homme. Vous devez simplement affecter le chemin de votre dossier à dirSize(String path) et obtenir un format lisible par l'homme en fonction de l'octet, du kilo, de la méga et etc.

     private static String dirSize(String path) { File dir = new File(path); if(dir.exists()) { long bytes = getFolderSize(dir); if (bytes < 1024) return bytes + " B"; int exp = (int) (Math.log(bytes) / Math.log(1024)); String pre = ("KMGTPE").charAt(exp-1) + ""; return String.format("%.1f %sB", bytes / Math.pow(1024, exp), pre); } return "0"; } public static long getFolderSize(File dir) { if (dir.exists()) { long result = 0; File[] fileList = dir.listFiles(); for(int i = 0; i < fileList.length; i++) { // Recursive call if it's a directory if(fileList[i].isDirectory()) { result += getFolderSize(fileList[i]); } else { // Sum the file size in bytes result += fileList[i].length(); } } return result; // return the file size } return 0; } 

    Le problème avec une autre solution est qu'ils ne vous fournissent que la taille logique de tous les fichiers dans le répertoire spécifié. Ce sera différent de l'espace réel (physique) utilisé. Si votre répertoire contient beaucoup de sous-répertoires et / ou de petits fichiers, il peut y avoir une énorme différence entre la taille logique et la taille réelle du répertoire.

    Voici ce que j'ai trouvé comment prendre en compte la structure physique de FS.

     public static long getDirectorySize(File directory, long blockSize) { File[] files = directory.listFiles(); if (files != null) { // space used by directory itself long size = file.length(); for (File file : files) { if (file.isDirectory()) { // space used by subdirectory size += getDirectorySize(file, blockSize); } else { // file size need to rounded up to full block sizes // (not a perfect function, it adds additional block to 0 sized files // and file who perfectly fill their blocks) size += (file.length() / blockSize + 1) * blockSize; } } return size; } else { return 0; } } 

    Vous pouvez utiliser StatFs pour obtenir la taille du bloc:

     public static long getDirectorySize(File directory) { StatFs statFs = new StatFs(directory.getAbsolutePath()); long blockSize; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) { blockSize = statFs.getBlockSizeLong() } else { blockSize = statFs.getBlockSize(); } return getDirectorySize(directory, blockSize); } 

    La méthode ci-dessous vous renvoie la taille du dossier: –

     public static long getFolderSize(File dir) { long size = 0; for (File file : dir.listFiles()) { if (file.isFile()) { // System.out.println(file.getName() + " " + file.length()); size += file.length(); } else size += getFolderSize(file); } return size; } 

    Méthode d'appel ci-dessus: –

     File file = new File(Environment.getExternalStorageDirectory().getPath()+"/urfoldername/"); long folder_size=getFolderSize(file); 

    Vous renvoie la taille du dossier.

    L'itération à travers tous les fichiers est inférieure à 5 lignes de code et la seule manière raisonnable de le faire. Si vous voulez devenir moche, vous pouvez également exécuter une commande système (Runtime.getRuntime (). Exec ("du");) et capturer la sortie;)

    Vous pouvez consulter MediaStore pour une taille d'annuaire sur le stockage interne. C'est beaucoup plus rapide qu'une méthode récursive obtenant la longueur de chaque fichier dans un répertoire. Vous devez avoir l'autorisation READ_EXTERNAL_STORAGE accordée.

    Exemple:

     /** * Query the media store for a directory size * * @param context * the application context * @param file * the directory on primary storage * @return the size of the directory */ public static long getFolderSize(Context context, File file) { File directory = readlink(file); // resolve symlinks to internal storage String path = directory.getAbsolutePath(); Cursor cursor = null; long size = 0; try { cursor = context.getContentResolver().query(MediaStore.Files.getContentUri("external"), new String[]{MediaStore.MediaColumns.SIZE}, MediaStore.MediaColumns.DATA + " LIKE ?", new String[]{path + "/%/%"}, null); if (cursor != null && cursor.moveToFirst()) { do { size += cursor.getLong(0); } while (cursor.moveToNext()); } } finally { if (cursor != null) { cursor.close(); } } return size; } /** * Canonicalize by following all symlinks. Same as "readlink -f file". * * @param file * a {@link File} * @return The absolute canonical file */ public static File readlink(File file) { File f; try { f = file.getCanonicalFile(); } catch (IOException e) { return file; } if (f.getAbsolutePath().equals(file.getAbsolutePath())) { return f; } return readlink(f); } 

    Usage:

     File DCIM = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM); long directorySize = getFolderSize(context, DCIM); String formattedSize = Formatter.formatFileSize(context, directorySize); System.out.println(DCIM + " " + formattedSize); 

    Sortie:

    / Stockage / émulé / 0 / DCIM 30.86 Mo

    coAndroid est un fan Android de Google, tout sur les téléphones Android, Android Wear, Android Dev et Android Games Apps.