wake-up-neo.com

Wie kann ich in Android die Größe eines Ordners auf der SD-Karte ermitteln?

Ist es möglich, auf einfache Weise die Größe eines Ordners auf der SD-Karte abzurufen? Ich verwende einen Ordner zum Zwischenspeichern von Bildern und möchte die Gesamtgröße aller zwischengespeicherten Bilder darstellen. Gibt es einen anderen Weg, als über jede Datei zu iterieren? Sie alle befinden sich in demselben Ordner?

26
Gunnar Lium

Gehen Sie einfach alle Dateien durch und addieren Sie deren Länge:

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

HINWEIS: Funktion von Hand geschrieben, damit sie nicht kompiliert werden konnte!

BEARBEITET: Rekursiver Anruf behoben.

BEARBEITET: dirList.length wurde in fileList.length geändert.

38
Moss

Hier ist ein Code, der Rekursion vermeidet und anstelle der logischen Größe auch die physische Größe berechnet:

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

sie sollten diesen Code verwenden:

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;
}
5
Linh Toòng
/**
 * 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;
}
5
Mehran

Der Weg von #Moss ist richtig. Dies ist mein Code für diejenigen, die Bytes in ein vom Menschen lesbares Format ändern möchten. Sie müssen lediglich den Pfad Ihres Ordners dirSize(String path) zuweisen und ein vom Menschen lesbares Format basierend auf Byte, Kilo, Mega usw. erhalten. 

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;
    } 
3
Hesam

Das Problem bei anderen Lösungen ist, dass Sie nur die logische Größe aller Dateien in dem angegebenen Verzeichnis angeben. Es unterscheidet sich vom tatsächlich verwendeten (physischen) Speicherplatz. Wenn Ihr Verzeichnis viele Unterverzeichnisse und/oder kleine Dateien enthält, kann es einen großen Unterschied zwischen der logischen und der tatsächlichen Größe des Verzeichnisses geben.

Hier habe ich herausgefunden, wie man die physische Struktur von FS berücksichtigt.

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

Sie können StatFs verwenden, um die Blockgröße zu erhalten:

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

unten Methode geben Sie die Größe des Ordners zurück: -

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

aufruf über Methode: -

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

long folder_size=getFolderSize(file);

geben Sie die Größe des Ordners zurück.

1
duggu

Sie können MediaStore nach einer Verzeichnisgröße im internen Speicher abfragen. Dies ist viel schneller als eine rekursive Methode, bei der die Länge jeder Datei in einem Verzeichnis ermittelt wird. Sie müssen über die Berechtigung READ_EXTERNAL_STORAGE verfügen.

Beispiel:

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

Verwendungszweck:

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

Ausgabe:

/ Speicher/emuliert/0/DCIM 30,86 MB

0
Jared Rummler

Hoffe das hilft

importiere das

import Android.text.format.Formatter;

Für die Dateigröße

public static String fileSize(File file, Context context) {
        return Formatter.formatFileSize(context, file.length());
    }

Für Ordnergröße

 public static String forlderSize(File file, Context context) {
        long length = 0;
        File[] folderFiles = file.listFiles();
        for (File f : folderFiles) {
            length += f.length();
        }

        return Formatter.formatFileSize(context, length);
    }
0
zaai

Das Durchlaufen aller Dateien umfasst weniger als 5 Zeilen Code und ist die einzig vernünftige Möglichkeit, dies zu tun. Wenn Sie hässlich werden möchten, können Sie auch einen Systembefehl ausführen (Runtime.getRuntime (). Exec ("du");) und die Ausgabe abfangen;).

0
Maurits Rijk