Determine if a File Is a PDF File 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 tutorial, we’ll explore several ways to determine whether a file is a PDF in Java, using an approach without third-party dependencies and with different libraries.

2. Detect by File Signature

The file signature is also known as the magic number. It’s a sequence of bytes at the beginning of the file that determines the file type.

The PDF file signature contains 25 50 44 46 2D in hexadecimal. We can encode it as an ASCII String “%PDF-“.

In this and the following sections, we’ll use the following constant that contains our PDF file to run the tests:

final File PDF_FILE = new File("src/test/resources/input.pdf");

We extract the first five bytes of the file and match them with this file signature to identify whether it’s a PDF:

@Test
void whenDetectPdfByFileSignature_thenCorrect() throws IOException {
    boolean isPdf = false;
    try (InputStream fis = new BufferedInputStream(new FileInputStream(PDF_FILE))) {
        byte[] bytes = new byte[5];
        if (fis.read(bytes) == 5) {
            String header = new String(bytes);
            isPdf = Objects.equals(header, "%PDF-");
        }
    }
    assertTrue(isPdf);
}

As we can see, only the first few bytes are required for the detection. Hence, it’s a lightweight approach, and we don’t need any third-party dependencies.

If we prefer using third-party dependencies instead of coding the detection ourselves, we could have the following three different choices. Internally, all of them also rely on the file signature for detection.

3. Detect Using Apache Tika

Apache Tika is an open-source toolkit providing a single interface for detecting various file types, including PDF. It’s handy if we need to perform multiple file type identifications in our application.

Let’s include the following Maven dependency in our pom.xml:

<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-core</artifactId>
    <version>3.1.0</version>
</dependency>

In this example, we simply call the detect() method to find out the MIME type of our file and consider the file a PDF if it’s application/pdf:

@Test
void whenDetectPdfByTika_thenCorrect() throws IOException {
    Tika tika = new Tika();
    boolean isPdf = Objects.equals(tika.detect(PDF_FILE), "application/pdf");
    assertTrue(isPdf);
}

4. Detect Using Apache PDFBox

Apache PDFBox is one of the prevalent open-source Java libraries for manipulating PDF files programmatically.

Let’s include the following Maven dependency in our pom.xml:

<dependency>
    <groupId>org.apache.pdfbox</groupId>
    <artifactId>pdfbox</artifactId>
    <version>3.0.4</version>
</dependency>

We use the Loader class to parse the PDF file. It throws an IOException if the file isn’t a valid PDF:

@Test
void whenDetectPdfByPdfBox_thenCorrect() throws IOException {
    boolean isPdf;
    try (PDDocument document = Loader.loadPDF(PDF_FILE)) {
        isPdf = true;
    } catch (IOException ioe) {
        isPdf = false;
    }
    assertTrue(isPdf);
}

Since PDDocument holds system resources, we must ensure it’s closed after using it to avoid a memory leak. This can be handled using a try-with-resources block, which closes resources that implement the Closable interface.

5. Detect Using iText

iText is another open-source Java library for manipulating PDF files programmatically.

We include the following Maven dependency to use iText:

<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext7-core</artifactId>
    <version>7.2.4</version>
</dependency>

We determine the file type by reading the file as a PdfDocument. PdfReader throws an ITextException if the file isn’t a valid PDF:

@Test
void whenDetectPdfByItext_thenCorrect() {
    boolean isPdf;
    try (PdfDocument pdfDoc = new PdfDocument(new PdfReader(PDF_FILE))) {
	isPdf = true;
    } catch (ITextException | IOException e) {
        isPdf = false;
    }
    assertTrue(isPdf);
}

Both Apache PDFBox and iText can detect the PDF file type, and they also read the whole document. They’re usually overkill if we only want to detect the file type, rather than manipulating it. A lightweight approach is always preferred in such scenarios.

6. Conclusion

In this article, we explored different ways of determining whether a file is a PDF.

Apache PDFBox and iText are the best for us if we require manipulating the PDF as well. If we’re concerned with the file types only, we can either verify the PDF file signature or use Apache Tika to avoid reading the whole PDF file.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.