Obtener tamaño de carpeta o archivo

¿Cómo puedo recuperar el tamaño de la carpeta o el archivo en Java?

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

Esto devuelve la longitud del archivo en bytes o 0si el archivo no existe. No hay una forma incorporada de obtener el tamaño de una carpeta, tendrá que recorrer el árbol de directorios de forma recursiva (utilizando el listFiles()método de un objeto de archivo que representa un directorio) y acumular el tamaño del directorio por sí mismo:

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

ADVERTENCIA : Este método no es lo suficientemente sólido para su uso en producción. directory.listFiles()puede volver nully causar un NullPointerException. Además, no considera enlaces simbólicos y posiblemente tenga otros modos de falla. Utilice este método .

Usando java-7 nio api, calcular el tamaño de la carpeta se puede hacer mucho más rápido.

Aquí hay un ejemplo listo para ejecutar que es robusto y no generará una excepción. Registrará los directorios en los que no puede ingresar o tuvo problemas para recorrer. Los enlaces simbólicos se ignoran y la modificación simultánea del directorio no causará más problemas de los necesarios.

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

Necesitas FileUtils#sizeOfDirectory(File)de commons-io .

Tenga en cuenta que deberá verificar manualmente si el archivo es un directorio, ya que el método genera una excepción si se le pasa un no directorio.

ADVERTENCIA : Este método (a partir de commons-io 2.4) tiene un error y puede producirse IllegalArgumentExceptionsi el directorio se modifica al mismo tiempo.

En Java 8:

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

Sería mejor usarlo Files::sizeen el paso del mapa, pero arroja una excepción marcada.

ACTUALIZACIÓN:
también debe tener en cuenta que esto puede generar una excepción si no se puede acceder a algunos de los archivos / carpetas. Vea esta pregunta y otra solución usando 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;
}

Para Java 8, esta es una forma correcta de hacerlo:

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

Es importante filtrar todos los directorios , porque no se garantiza que el método de longitud sea 0 para los directorios.

Al menos este código ofrece la misma información de tamaño que el propio Explorador de Windows.

Esta es la mejor manera de obtener el tamaño de un archivo general (funciona para directorio y no directorio):

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

Editar: tenga en cuenta que probablemente esta operación llevará mucho tiempo. No lo ejecutes en el hilo de la interfaz de usuario.

Además, aquí (tomado de https://stackoverflow.com/a/5599842/1696171 ) hay una buena manera de obtener una cadena legible por el usuario de la devolución larga:

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

Si desea utilizar Java 8 NIO API, el siguiente programa imprimirá el tamaño, en bytes, del directorio en el que se encuentra.

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

}

El calculateSizemétodo es universal para Pathobjetos, por lo que también funciona para archivos. Tenga en cuenta que si un archivo o directorio es inaccesible, en este caso, el tamaño devuelto del objeto de ruta será 0.

File.length()( Javadoc ).

Tenga en cuenta que esto no funciona para directorios o no se garantiza que funcione.

Para un directorio, ¿qué quieres? Si es el tamaño total de todos los archivos debajo de él, puede caminar recursivamente a los niños usando File.list()y File.isDirectory()y sumar sus tamaños.

El Fileobjeto tiene un lengthmétodo:

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

• Funciona para Android y Java
• Funciona tanto para carpetas como para archivos
• Comprueba si hay puntero nulo en todas partes donde sea necesario
• Ignora el enlace simbólico también conocido como atajos
• ¡Producción lista!

Código fuente:

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

para Windows, usando java.io esta función reccursiva es útil.

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

Esto está probado y funciona correctamente por mi parte.

He probado du -c <folderpath>y es 2 veces más rápido que nio.Files o recursividad

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

Después de mucha investigación y análisis de las diferentes soluciones propuestas aquí en StackOverflow. Finalmente decidí escribir mi propia solución. Mi propósito es tener un mecanismo de no tirar porque no quiero fallar si la API no puede recuperar el tamaño de la carpeta. Este método no es adecuado para escenarios de subprocesos múltiples.

En primer lugar, quiero comprobar los directorios válidos mientras recorro el árbol del sistema de archivos.

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

En segundo lugar, no quiero que mi llamada recursiva entre en enlaces simbólicos (enlaces suaves) e incluya el tamaño en total agregado.

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

Finalmente, mi implementación basada en recursividad para obtener el tamaño del directorio especificado. Observe la comprobación nula de dir.listFiles (). Según javadoc, existe la posibilidad de que este método pueda devolver un valor nulo.

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

Un poco de crema en el pastel, la API para obtener el tamaño de los archivos de la lista (pueden ser todos los archivos y carpetas en la raíz).

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

en linux si desea ordenar directorios entonces du -hs * | sort -h

Puede utilizar Apache Commons IOpara encontrar el tamaño de la carpeta fácilmente.

Si está en maven, agregue la siguiente dependencia en su pom.xmlarchivo.

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

Si no eres fanático de Maven, descarga el siguiente jar y agrégalo a la ruta de clases.

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
}

Para obtener el tamaño del archivo a través de Commons IO,

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

long fileSize = FileUtils.sizeOf(file);

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

También se puede lograr a través de Google Guava

Para Maven, agregue lo siguiente:

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

Si no usa Maven, agregue lo siguiente a la ruta de clases

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

Para obtener el tamaño del archivo,

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