File Size in Java

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.

The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.

In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:

>> How to Run Selenium Regression Tests With GitHub Actions

1. Overview

In this quick tutorial, we’ll learn how to get the size of a file in Java – using Java 7, the new Java 8 and Apache Common IO.

Finally – we will also get a human readable representation of the file size.

2. Standard Java IO

Let’s start with a simple example of calculating the size of a file – using the File.length() method:

private long getFileSize(File file) {
    long length = file.length();
    return length;
}

We can test our implementation relatively simply:

@Test
public void whenGetFileSize_thenCorrect() {
    long expectedSize = 12607;
 
    File imageFile = new File("src/test/resources/image.jpg");
    long size = getFileSize(imageFile);
 
    assertEquals(expectedSize, size);
}

Note that, by default, the file sizes is calculated in bytes.

3. With Java NIO

Next – let’s see how to use the NIO library to get the size of the file.

In the following example, we’ll use the FileChannel.size() API to get the size of a file in bytes:

@Test
public void whenGetFileSizeUsingNioApi_thenCorrect() throws IOException {
    long expectedSize = 12607;
 
    Path imageFilePath = Paths.get("src/test/resources/image.jpg");
    FileChannel imageFileChannel = FileChannel.open(imageFilePath);

    long imageFileSize = imageFileChannel.size();
    assertEquals(expectedSize, imageFileSize);
}

4. With Apache Commons IO

Next – let’s see how to get the file size using Apache Commons IO. In the following example – we simply use FileUtils.sizeOf() to get the file size:

@Test
public void whenGetFileSizeUsingApacheCommonsIO_thenCorrect() {
    long expectedSize = 12607;
 
    File imageFile = new File("src/test/resources/image.jpg");
    long size = FileUtils.sizeOf(imageFile);
 
    assertEquals(expectedSize, size);
}

Note that, for security restricted files, FileUtils.sizeOf() will report the size as zero.

5. Human Readable Size

Finally – let’s see how to get a more user readable representation of the file size using Apache Commons IO – not just a size in bytes:

@Test
public void whenGetReadableFileSize_thenCorrect() {
    File imageFile = new File("src/test/resources/image.jpg");
    long size = getFileSize(imageFile);
 
    assertEquals("12 KB", FileUtils.byteCountToDisplaySize(size));
}

6. How to Get the Size of a File in MB, KB & GB in Java

To get the size of a file in megabytes (MB), kilobytes (KB), and gigabytes (GB) in Java, we need first to understand the relation between these units. It’s known that :

1 kilobyte (KB) = 1,024 bytes
1 megabyte (MB) = 1,024 KB
gigabyte (GB) = 1,024 MB and

We can then conclude the following mathematical formulas to convert from a lower level of data size (e.g., bytes) to a higher level (e.g., kilobytes) and then to an even higher level (e.g., megabytes):

Kilobytes = Bytes / 1024
Megabytes = Kilobytes / 1024
Gegabytes = Megabytes / 1024

let’s create a Java method that uses the previous mathematical formulas:

private void getSizeOfFile(String pathname) {
    File file = new File(pathname);
    if (file.exists()) {
        // File size in bytes
        long bytes = file.length();
        double kilobytes = (double) bytes / 1024;
        double megabytes = kilobytes / 1024;
        double gigabytes = megabytes / 1024;
        System.out.println("File size in bytes: " + bytes + " bytes");
        System.out.println("File size in kilobytes: " + kilobytes + " KB");
        System.out.println("File size in megabytes: " + megabytes + " MB");
        System.out.println("File size in gigabytes: " + gigabytes + " GB");
    } else {
        System.out.println("File not found.");
    }
}

The above code first checks if the file exists and if it does, it calculates and prints its size in bytes, kilobytes, megabytes, and gigabytes.