Check if a File Is Empty in Java

1. Overview

We often encounter scenarios where we need to work with files in our Java applications. Sometimes, we want to determine whether a file is empty before proceeding with further operations.

In this tutorial, we’ll explore a few efficient and straightforward ways to check if a file is empty in Java.

2. Introduction to the Problem

Before we dive into the implementation, let’s understand what it means for a file to be empty.

In the context of file operations, an empty file refers to a file that contains no data or has a size of zero bytes.

Validating whether a file is empty can be particularly useful when dealing with input or output operations, such as reading or parsing files.

The Java standard library provides methods to get the size of a file. However, we need to pay attention to some pitfalls.

For simplicity, we’ll use unit test assertions to verify whether our approach works as expected. Furthermore, JUnit 5’s TempDirectory extension allows us to create and clean up temporary directories in unit tests easily. As our tests are file-related, we’ll use this extension to support our verification.

3. Using the File.length() Method

We understand that we can determine if a file is empty or not by checking the file’s size. The Java standard IO library provides the File.length() method to calculate the size of a file in bytes.

So, we can solve our problem by checking if File.length() returns 0:

@Test
void whenTheFileIsEmpty_thenFileLengthIsZero(@TempDir Path tempDir) throws IOException {
    File emptyFile = tempDir.resolve("an-empty-file.txt")
      .toFile();
    emptyFile.createNewFile();
    assertTrue(emptyFile.exists());
    assertEquals(0, emptyFile.length());
}

Calling File.length() to check if a file is empty is handy. But there’s a pitfall. Let’s understand it by another test:

@Test
void whenFileDoesNotExist_thenFileLengthIsZero(@TempDir Path tempDir) {
    File aNewFile = tempDir.resolve("a-new-file.txt")
      .toFile();
    assertFalse(aNewFile.exists());
    assertEquals(0, aNewFile.length());
}

In the test above, we initialized a File object as usual. However, we didn’t create the file. In other words, the file tempDir/a-new-file.txt doesn’t exist.

So the test shows that when we call the File.length() on a non-existent file, it also returns 0. Usually, when we talk about a file being empty, the file must exist. Therefore, it’s unreliable to apply the empty-check only by File.length() alone.

So next, let’s create a method to solve the problem:

boolean isFileEmpty(File file) {
    if (!file.exists()) {
        throw new IllegalArgumentException("Cannot check the file length. The file is not found: " + file.getAbsolutePath());
    }
    return file.length() == 0;
}

In the method above, we raise the IllegalArgumentException in case the file doesn’t exist. Some may consider that the FileNotFoundException is the more appropriate one. Here, we didn’t pick FileNotFoundException as it’s a checked exception. If we throw this exception when we call our isFileEmpty() method, we have to handle the exception. On the other hand, IllegalArgumentException is an unchecked exception, indicating the file argument isn’t valid.

Now, the isFileEmpty() method does the job no matter whether the file exists or not:

@Test
void whenTheFileDoesNotExist_thenIsFilesEmptyThrowsException(@TempDir Path tempDir) {
    File aNewFile = tempDir.resolve("a-new-file.txt")
      .toFile();
    IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> isFileEmpty(aNewFile));
    assertEquals(ex.getMessage(), "Cannot check the file length. The file is not found: " + aNewFile.getAbsolutePath());
}

@Test
void whenTheFileIsEmpty_thenIsFilesEmptyReturnsTrue(@TempDir Path tempDir) throws IOException {
    File emptyFile = tempDir.resolve("an-empty-file.txt")
      .toFile();
    emptyFile.createNewFile();
    assertTrue(isFileEmpty(emptyFile));
}

4. Using the NIO Files.size() Method

We’ve solved the problem using File.length().

File.length() is from standard Java IO. Alternatively, if we’re using Java version 7 or later, we can solve the problem using the Java NIO API. For example, java.nio.file.Files.size() returns the size of a file, which can also help us to check if a file is empty.

It’s worth mentioning that Java NIO’s Files.size() throws the NoSuchFileException if the file doesn’t exist:

@Test
void whenTheFileIsEmpty_thenFilesSizeReturnsTrue(@TempDir Path tempDir) throws IOException {
    Path emptyFilePath = tempDir.resolve("an-empty-file.txt");
    Files.createFile(emptyFilePath);
    assertEquals(0, Files.size(emptyFilePath));
}

@Test
void whenTheFileDoesNotExist_thenFilesSizeThrowsException(@TempDir Path tempDir) {
    Path aNewFilePath = tempDir.resolve("a-new-file.txt");
    assertThrows(NoSuchFileException.class, () -> Files.size(aNewFilePath));
}

5. Conclusion

In this article, we’ve explored two approaches to checking if a file is empty in Java:

• Using File.length() from Java Standard IO
• Using Files.size() from Java NIO