Java 获取文件夹或文件的大小

如何在Java中检索文件夹或文件的大小？

file.length

请注意，这对目录不起作用，或者不能保证起作用

对于目录，您想要什么？如果是其下所有文件的总大小，则可以使用File.list和File.isDirectory递归遍历子对象，并对其大小求和。

文件对象有一个长度方法：

这将返回文件的长度（以字节为单位），如果文件不存在，则返回0。没有获取文件夹大小的内置方法，您必须使用表示目录的文件对象的listFiles方法递归遍历目录树，并为自己累积目录大小：

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

警告：对于生产使用，此方法不够可靠。directory.listFiles可能返回null并导致NullPointerException。此外，它不考虑SysLink，可能还有其他故障模式。使用。

您需要从

请注意，如果将非目录传递给该文件，则该方法会引发异常，因此需要手动检查该文件是否为目录

---

警告：从commons io 2.4开始，此方法有一个错误，如果同时修改目录，可能引发IllegalArgumentException。

使用java-7 nio api，计算文件夹大小可以更快

下面是一个准备运行的示例，它非常健壮，不会引发异常。它将记录无法进入或无法遍历的目录。符号链接将被忽略，同时修改目录不会带来更多的麻烦

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

在Java 8中：

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

最好在映射步骤中使用Files:：size，但它会抛出一个选中的异常

更新：

---

您还应该知道，如果某些文件/文件夹不可访问，这可能引发异常。使用查看此解决方案和另一个解决方案。

以下是获得适用于目录和非目录的常规文件大小的最佳方法：

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

编辑：请注意，这可能是一个耗时的操作。不要在UI线程上运行它

另外，这里是从返回的长字符串中获取用户可读字符串的好方法：

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

---

在对StackOverflow提出的不同解决方案进行了大量研究之后。我最终决定写我自己的解决方案。我的目的是没有抛出机制，因为如果API无法获取文件夹大小，我不想崩溃。此方法不适用于多线程场景

首先，我想在遍历文件系统树时检查有效目录

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

其次，我不希望我的递归调用进入符号链接软链接，并将大小包含在总聚合中

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

最后，我将使用基于递归的实现来获取指定目录的大小。请注意dir.listFiles的空检查。根据javadoc，这个方法有可能返回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;
    }
}

一些奶油蛋糕，API获得的文件列表的大小可能是所有文件和文件夹下的根

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

对于Java 8，这是一种正确的方法：

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

筛选出所有目录很重要，因为对于目录，length方法不能保证为0

至少这段代码提供了与Windows资源管理器本身相同的大小信息。

如果要使用Java 8 NIO API，以下程序将以字节为单位打印它所在目录的大小

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

}

calculateSize方法对于路径对象是通用的，因此它也适用于文件。

---

请注意，如果文件或目录不可访问，在这种情况下，path对象返回的大小将为0。

在linux中，如果要对目录进行排序，请使用du-hs*| sort-h

适用于Android和Java 适用于文件夹和文件 在需要的任何地方检查空指针 忽略快捷方式 生产准备就绪！ 源代码：

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

---

对于windows，使用java.io这个递归函数很有用

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

这在我这方面已经过测试并正常工作。

您可以使用Apache Commons IO轻松找到文件夹大小

如果您使用的是maven，请在pom.xml文件中添加以下依赖项

要通过Commons IO获取文件大小

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

long fileSize = FileUtils.sizeOf(file);

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

这也可以通过谷歌番石榴实现

对于Maven，添加以下内容：

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

我测试过du-c，比nio.Files或递归快2倍

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

---

@Vishal您的代码需要有一个简单的修复，在递归调用中，您应该将大小添加到现有大小，而不仅仅是分配给它。size+=getFolderSizefile@Teja：谢谢你指出，但是更改也会出现在if语句中，有时在一个不断增长的文件夹上，另一个线程正在下载文件和文件夹，同时我正在打印文件夹大小，这会在文件File:dir.listFiles的第行出现nullpointerexception{。一些文件在活动文件夹中快速出现和消失。因此，我在for循环之前为dir.listFiles返回值添加了null检查。From File.listFiles javadoc:ar

---

如果目录为空，则ray将为空。如果此抽象路径名不表示目录，或者发生I/O错误，则返回null。因此，在获取动态更改文件夹的文件夹大小时，上述注释非常有用；那里有一个系统文件，根据java.io.file，它既不是文件也不是目录。您可能希望更改else子句以检查文件是否实际上是一个目录。简单更改以检查参数以查看它在方法开头是否不是一个目录并返回长度，则递归更简单-只需在同一方法中添加对self的调用，然后这就支持传入文件引用，而不是还有一个目录。如果你使用Java 7或更高版本，使用这个答案会快得多。这会被符号链接弄糊涂。此外，如果同时修改目录，它可能会抛出NullPointerException。那么当文件不是目录时会发生什么呢？当它不存在的时候？等等——真糟糕docs@Mr_and_Mrs_D-只需复制并粘贴checkDirectorydirectory后的行；检查只需确保File.listFiles有子文件。参考文献：，见错误。如果目录在迭代时被修改，此方法将抛出IllegalArgumentException。哎哟！！！那太糟糕了…是的，它列出了文件，如果在代码运行时删除了一个文件，它抛出。在Android开发中是否有类似的方法？是否有理由使用AtomicLong而不是long？从匿名classI访问变量时必须是最终的。我使用JMH做了一个基准测试，与在一个包含多个子文件夹的文件夹上测试的commons io代码相比，这种NIO api方法的速度大约快4到5倍总共有180229个文件。Commons IO用了15秒，NIO用了5秒。这种方法是最健壮的。它处理符号链接、并发修改、安全异常、同时处理文件和目录等。糟糕的是，文件不直接支持它！我研究了一些类似的问题，最后得到了有问题的代码：，正如您所看到的，错误处理的另一个方面也会导致问题。@AkselWillgert谢谢，这很不幸，我已经更新了答案。现在切换到番石榴，但关注的是效率：如果你碰巧在Android上，那么看看StatFs。它使用文件系统统计数据，比递归方法快近1000倍，因为递归方法无法满足我们的需要。我们的实现可以在这里找到：虽然您的代码看起来不错，但我不确定它是否为其他答案添加了任何内容。如果有，请编辑您的答案进行解释。这只是用更少的代码行完成相同工作的更新版本。

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

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

public long getFolderSize() {

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

    return size; // in bytes
}

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

long fileSize = FileUtils.sizeOf(file);

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

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

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

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

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