Nhận kích thước của thư mục hoặc tệp

Làm cách nào để truy xuất kích thước của thư mục hoặc tệp trong Java?

java.io.File file = new java.io.File("myfile.txt");
file.length();

Điều này trả về độ dài của tệp tính bằng byte hoặc 0nếu tệp không tồn tại. Không có cách nào tích hợp sẵn để lấy kích thước của một thư mục, bạn sẽ phải duyệt đệ quy cây thư mục (sử dụng listFiles()phương thức của một đối tượng tệp đại diện cho một thư mục) và tích lũy kích thước thư mục cho chính mình:

public static long folderSize(File directory) {
    long length = 0;
    for (File file : directory.listFiles()) {
        if (file.isFile())
            length += file.length();
        else
            length += folderSize(file);
    }
    return length;
}

CẢNH BÁO : Phương pháp này không đủ mạnh để sử dụng trong sản xuất. directory.listFiles()có thể trở lại nullvà gây ra a NullPointerException. Ngoài ra, nó không xem xét các liên kết tượng trưng và có thể có các chế độ lỗi khác. Sử dụng phương pháp này .

Sử dụng java-7 nio api, việc tính toán kích thước thư mục có thể được thực hiện nhanh hơn rất nhiều.

Đây là một ví dụ sẵn sàng để chạy, mạnh mẽ và sẽ không đưa ra ngoại lệ. Nó sẽ ghi lại các thư mục mà nó không thể nhập hoặc gặp sự cố khi duyệt. Các liên kết tượng trưng bị bỏ qua và việc sửa đổi đồng thời thư mục sẽ không gây ra nhiều rắc rối hơn mức cần thiết.

/**
 * Attempts to calculate the size of a file or directory.
 * 
 * <p>
 * Since the operation is non-atomic, the returned value may be inaccurate.
 * However, this method is quick and does its best.
 */
public static long size(Path path) {

    final AtomicLong size = new AtomicLong(0);

    try {
        Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {

                size.addAndGet(attrs.size());
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path file, IOException exc) {

                System.out.println("skipped: " + file + " (" + exc + ")");
                // Skip folders that can't be traversed
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) {

                if (exc != null)
                    System.out.println("had trouble traversing: " + dir + " (" + exc + ")");
                // Ignore errors traversing a folder
                return FileVisitResult.CONTINUE;
            }
        });
    } catch (IOException e) {
        throw new AssertionError("walkFileTree will not throw IOException if the FileVisitor does not");
    }

    return size.get();
}

Bạn cần FileUtils#sizeOfDirectory(File)từ commons-io .

Lưu ý rằng bạn sẽ cần phải kiểm tra thủ công xem tệp có phải là một thư mục hay không vì phương pháp ném một ngoại lệ nếu một thư mục không phải được chuyển đến nó.

CẢNH BÁO : Phương pháp này (kể từ commons-io 2.4) có một lỗi và có thể bị lỗi IllegalArgumentExceptionnếu thư mục được sửa đổi đồng thời.

Trong Java 8:

long size = Files.walk(path).mapToLong( p -> p.toFile().length() ).sum();

Nó sẽ đẹp hơn nếu sử dụng Files::sizetrong bước bản đồ nhưng nó ném ra một ngoại lệ đã được kiểm tra.

CẬP NHẬT:
Bạn cũng nên biết rằng điều này có thể tạo ra một ngoại lệ nếu một số tệp / thư mục không thể truy cập được. Xem câu hỏi này và một giải pháp khác bằng Guava .

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

Đối với Java 8, đây là một cách đúng đắn để làm điều đó:

Files.walk(new File("D:/temp").toPath())
                .map(f -> f.toFile())
                .filter(f -> f.isFile())
                .mapToLong(f -> f.length()).sum()

Điều quan trọng là phải lọc ra tất cả các thư mục , vì phương thức length không được đảm bảo là 0 cho các thư mục.

Ít nhất thì mã này cung cấp thông tin về kích thước giống như chính Windows Explorer.

Đây là cách tốt nhất để có được kích thước chung của Tệp (hoạt động cho thư mục và không phải thư mục):

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

Chỉnh sửa: Lưu ý rằng đây có thể sẽ là một hoạt động tốn thời gian. Đừng chạy nó trên chuỗi giao diện người dùng.

Ngoài ra, đây (được lấy từ https://stackoverflow.com/a/5599842/1696171 ) là một cách hay để có được Chuỗi người dùng có thể đọc được từ lâu được trả về:

public static String getReadableSize(long size) {
    if(size <= 0) return "0";
    final String[] units = new String[] { "B", "KB", "MB", "GB", "TB" };
    int digitGroups = (int) (Math.log10(size)/Math.log10(1024));
    return new DecimalFormat("#,##0.#").format(size/Math.pow(1024, digitGroups))
            + " " + units[digitGroups];
}

Nếu bạn muốn sử dụng Java 8 NIO API, chương trình sau sẽ in ra kích thước, tính bằng byte, của thư mục mà nó nằm trong đó.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class PathSize {

    public static void main(String[] args) {
        Path path = Paths.get(".");
        long size = calculateSize(path);
        System.out.println(size);
    }

    /**
     * Returns the size, in bytes, of the specified <tt>path</tt>. If the given
     * path is a regular file, trivially its size is returned. Else the path is
     * a directory and its contents are recursively explored, returning the
     * total sum of all files within the directory.
     * <p>
     * If an I/O exception occurs, it is suppressed within this method and
     * <tt>0</tt> is returned as the size of the specified <tt>path</tt>.
     * 
     * @param path path whose size is to be returned
     * @return size of the specified path
     */
    public static long calculateSize(Path path) {
        try {
            if (Files.isRegularFile(path)) {
                return Files.size(path);
            }

            return Files.list(path).mapToLong(PathSize::calculateSize).sum();
        } catch (IOException e) {
            return 0L;
        }
    }

}

Các calculateSizephương pháp mang tính phổ quát cho Pathđối tượng, vì vậy nó cũng làm việc cho các tập tin. Lưu ý rằng nếu một tệp hoặc thư mục không thể truy cập được, trong trường hợp này, kích thước trả về của đối tượng đường dẫn sẽ là 0.

File.length()( Javadoc ).

Lưu ý rằng điều này không hoạt động cho các thư mục hoặc không được đảm bảo hoạt động.

Đối với một thư mục, bạn muốn gì? Nếu đó là tổng kích thước của tất cả các file bên dưới nó, bạn có thể đi bộ một cách đệ quy trẻ em sử dụng File.list()và File.isDirectory()và tổng kích thước của chúng.

Đối Filetượng có một lengthphương thức:

f = new File("your/file/name");
f.length();

• Hoạt động cho Android và Java
• Hoạt động cho cả thư mục và tệp
• Kiểm tra con trỏ rỗng ở mọi nơi nếu cần
• Bỏ qua liên kết tượng trưng hay còn gọi là phím tắt
• Sản xuất đã sẵn sàng!

Mã nguồn:

   public long fileSize(File root) {
        if(root == null){
            return 0;
        }
        if(root.isFile()){
            return root.length();
        }
        try {
            if(isSymlink(root)){
                return 0;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return 0;
        }

        long length = 0;
        File[] files = root.listFiles();
        if(files == null){
            return 0;
        }
        for (File file : files) {
            length += fileSize(file);
        }

        return length;
    }

    private static boolean isSymlink(File file) throws IOException {
        File canon;
        if (file.getParent() == null) {
            canon = file;
        } else {
            File canonDir = file.getParentFile().getCanonicalFile();
            canon = new File(canonDir, file.getName());
        }
        return !canon.getCanonicalFile().equals(canon.getAbsoluteFile());
    }

đối với windows, sử dụng java.io, hàm reccursive này rất hữu ích.

    public static long folderSize(File directory) {
    long length = 0;

    if (directory.isFile())
         length += directory.length();
    else{
        for (File file : directory.listFiles()) {
             if (file.isFile())
                 length += file.length();
             else
                 length += folderSize(file);
        }
    }

    return length;
}

Điều này đã được kiểm tra và hoạt động tốt trên đầu của tôi.

Tôi đã thử nghiệm du -c <folderpath>và nhanh hơn gấp 2 lần so với nio.

private static long getFolderSize(File folder){
  if (folder != null && folder.exists() && folder.canRead()){
    try {
      Process p = new ProcessBuilder("du","-c",folder.getAbsolutePath()).start();
      BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
      String total = "";
      for (String line; null != (line = r.readLine());)
        total = line;
      r.close();
      p.waitFor();
      if (total.length() > 0 && total.endsWith("total"))
        return Long.parseLong(total.split("\\s+")[0]) * 1024;
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }
  return -1;
}

public long folderSize (String directory)
    {
        File curDir = new File(directory);
        long length = 0;
        for(File f : curDir.listFiles())
        {
            if(f.isDirectory())
            {               
                 for ( File child : f.listFiles()) 
                 {
                     length = length + child.length();
                 }

                System.out.println("Directory: " + f.getName() + " " + length + "kb");
            }
            else
            {
                length = f.length();
                System.out.println("File: " + f.getName() + " " + length + "kb");
            }
            length = 0;
        }
        return length;
    }

Sau rất nhiều nghiên cứu và xem xét các giải pháp khác nhau được đề xuất ở đây tại StackOverflow. Cuối cùng tôi quyết định viết giải pháp của riêng mình. Mục đích của tôi là có cơ chế no-throw vì tôi không muốn gặp sự cố nếu API không thể tìm nạp kích thước thư mục. Phương pháp này không phù hợp với kịch bản mult-threaded.

Trước hết, tôi muốn kiểm tra các thư mục hợp lệ trong khi duyệt xuống cây hệ thống tệp.

private static boolean isValidDir(File dir){
    if (dir != null && dir.exists() && dir.isDirectory()){
        return true;
    }else{
        return false;
    }
}

Thứ hai, tôi không muốn lời gọi đệ quy của mình đi vào các liên kết tượng trưng (liên kết mềm) và bao gồm tổng kích thước trong tổng số.

public static boolean isSymlink(File file) throws IOException {
    File canon;
    if (file.getParent() == null) {
        canon = file;
    } else {
        canon = new File(file.getParentFile().getCanonicalFile(),
                file.getName());
    }
    return !canon.getCanonicalFile().equals(canon.getAbsoluteFile());
}

Cuối cùng, triển khai dựa trên đệ quy của tôi để tìm nạp kích thước của thư mục được chỉ định. Lưu ý kiểm tra null cho dir.listFiles (). Theo javadoc, phương thức này có thể trả về null.

public static long getDirSize(File dir){
    if (!isValidDir(dir))
        return 0L;
    File[] files = dir.listFiles();
    //Guard for null pointer exception on files
    if (files == null){
        return 0L;
    }else{
        long size = 0L;
        for(File file : files){
            if (file.isFile()){
                size += file.length();
            }else{
                try{
                    if (!isSymlink(file)) size += getDirSize(file);
                }catch (IOException ioe){
                    //digest exception
                }
            }
        }
        return size;
    }
}

Một ít kem trên bánh, API để lấy kích thước của danh sách Tệp (có thể là tất cả các tệp và thư mục dưới gốc).

public static long getDirSize(List<File> files){
    long size = 0L;
    for(File file : files){
        if (file.isDirectory()){
            size += getDirSize(file);
        } else {
            size += file.length();
        }
    }
    return size;
}

trong linux nếu bạn muốn sắp xếp thư mục thì du -hs * | sắp xếp -h

Bạn có thể sử dụng Apache Commons IOđể tìm kích thước thư mục một cách dễ dàng.

Nếu bạn đang sử dụng maven, vui lòng thêm phần phụ thuộc sau vào pom.xmltệp của bạn .

<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

Nếu không phải là fan của Maven, hãy tải xuống jar sau và thêm nó vào đường dẫn lớp.

https://repo1.maven.org/maven2/commons-io/commons-io/2.6/commons-io-2.6.jar

public long getFolderSize() {

    File folder = new File("src/test/resources");
    long size = FileUtils.sizeOfDirectory(folder);

    return size; // in bytes
}

Để nhận kích thước tệp qua Commons IO,

File file = new File("ADD YOUR PATH TO FILE");

long fileSize = FileUtils.sizeOf(file);

System.out.println(fileSize); // bytes

Nó cũng có thể đạt được thông qua Google Guava

Đối với Maven, hãy thêm những thứ sau:

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>28.1-jre</version>
</dependency>

Nếu không sử dụng Maven, hãy thêm phần sau vào đường dẫn lớp

https://repo1.maven.org/maven2/com/google/guava/guava/28.1-jre/guava-28.1-jre.jar

public long getFolderSizeViaGuava() {
        File folder = new File("src/test/resources");
        Iterable<File> files = Files.fileTreeTraverser()
                .breadthFirstTraversal(folder);
        long size = StreamSupport.stream(files.spliterator(), false)
                .filter(f -> f.isFile())
                .mapToLong(File::length).sum();

        return  size;
    }

Để có kích thước tệp,

 File file = new File("PATH TO YOUR FILE");
 long s  = file.length();
 System.out.println(s);

private static long getFolderSize(Path folder) {
        try {
            return Files.walk(folder)
                      .filter(p -> p.toFile().isFile())
                      .mapToLong(p -> p.toFile().length())
                      .sum();
        } catch (IOException e) {
            e.printStackTrace();
            return 0L;
        }