Làm thế nào tôi có thể nhận được kích thước của một thư mục trên thẻ SD trong Android?

Question

Có thể dễ dàng lấy kích thước của một thư mục trên thẻ SD không? Tôi sử dụng một thư mục cho bộ nhớ đệm của hình ảnh, và muốn trình bày tổng kích thước của tất cả các hình ảnh được lưu trữ. Có cách nào khác hơn là lặp qua mỗi tập tin? Tất cả chúng đều nằm trong cùng một thư mục?

Answer 1

Chỉ cần đi qua tất cả các file và tổng chiều dài của họ:

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

Chú ý: Chức năng viết bằng tay nên không thể biên dịch!

CHỈNH SỬA: cuộc gọi đệ quy đã được sửa.

CHỈNH SỬA: dirList.length đổi thành fileList.length.

Answer 2

Lặp lại tất cả các tệp có ít hơn 5 dòng mã và cách hợp lý duy nhất để thực hiện việc này. Nếu bạn muốn nhận được xấu xí bạn cũng có thể chạy một lệnh hệ thống (Runtime.getRuntime() exec ("du");.) Và bắt đầu ra;)

Answer 3

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

Answer 4

dưới phương pháp trả lại cho bạn kích thước của thư mục: -

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

gọi phương pháp nêu trên: -

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

long folder_size=getFolderSize(file); 

bù lại bạn kích thước của thư mục.

Answer 5

Cách của #Moss là đúng. Đây là mã của tôi cho những ai muốn thay đổi byte thành định dạng có thể đọc được của con người. Bạn chỉ cần gán con đường của thư mục của bạn để dirSize(String path) và nhận dạng có thể đọc được con người dựa trên byte, kg, mega và vv

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

Answer 6

Vấn đề với giải pháp khác là họ cung cấp cho bạn chỉ kích thước hợp lý của tất cả các tập tin trong định danh mục. Nó sẽ khác với không gian sử dụng thực tế (vật lý). Nếu thư mục của bạn có rất nhiều thư mục con và/hoặc các tệp nhỏ, có thể có sự khác biệt lớn giữa kích thước thư mục và kích thước thực tế.

Dưới đây là những gì tôi đã tìm hiểu cách tính số lượng cấu trúc vật lý của 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; 
    } 
} 

Bạn có thể sử dụng StatFs để có được kích thước khối:

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

Answer 7

bạn nên sử dụng mã này:

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

Answer 8

Dưới đây là một số mã mà tránh đệ quy, và cũng có thể tính toán kích thước vật lý thay vì có kích thước lôgic:

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

Answer 9

Bạn có thể truy vấn MediaStore cho kích thước thư mục trên bộ nhớ trong. Điều này là nhanh hơn nhiều so với một phương pháp đệ quy nhận được chiều dài của mỗi tập tin trong một thư mục. Bạn phải có sự cho phép READ_EXTERNAL_STORAGE.

Ví dụ:

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

Cách sử dụng:

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

Output:

/lưu trữ/mô phỏng/0/DCIM 30.86 MB