DEV Community: Leon Davis

How to Fill PDF Form Fields in Java: Text Box, Checkbox, Combo Box & List Box

Leon Davis — Fri, 24 Jul 2026 11:50:06 +0000

PDF forms are widely used for registration forms, applications, surveys, contract confirmations, and business approval processes. Unlike ordinary PDF documents, interactive PDF forms contain fields such as text boxes, checkboxes, radio buttons, combo boxes, and list boxes that can be filled programmatically.

When generating large numbers of application forms, importing customer data, or exporting completed forms from a business system, filling each form manually is inefficient. With Java, form fields can be read and populated automatically as part of a backend service, desktop application, or batch-processing workflow.

This article explains how to:

Read form fields from a PDF
Fill text boxes
Select radio button options
Check or clear checkboxes
Select items in list boxes and combo boxes
Populate fields based on their names
Save the completed PDF document

This method applies to PDF files that contain interactive form fields. It does not work directly with scanned PDFs, image-based forms, ordinary page content, or forms that have already been flattened.

1. Install the Required Java Library

The Java standard library does not provide built-in APIs for reading and filling PDF forms, so a third-party PDF library is required.

The examples in this article use Spire.PDF for Java to access and populate interactive form fields.

Option 1: Add the JAR File Manually

Download the library from:

Download Spire.PDF for Java

After extracting the downloaded package, add Spire.Pdf.jar to the project build path.

In IntelliJ IDEA, open:

File > Project Structure > Modules > Dependencies

Then add the JAR file.

In Eclipse, right-click the project and select:

Build Path > Configure Build Path > Libraries

Then add the JAR file.

Option 2: Add the Maven Dependency

For Maven projects, add the following repository and dependency settings to pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.6.4</version>
    </dependency>
</dependencies>

2. Common PDF Form Field Types

A PDF form may contain several types of interactive controls. The program must first determine the field type before assigning a value.

Form field	Corresponding class	Common method
Text box	`PdfTextBoxFieldWidget`	`setText()`
Radio button group	`PdfRadioButtonListFieldWidget`	`setSelectedIndex()`
List box	`PdfListBoxWidgetFieldWidget`	`setSelectedIndex()`
Checkbox	`PdfCheckBoxWidgetFieldWidget`	`setChecked()`
Combo box	`PdfComboBoxWidgetFieldWidget`	`setSelectedIndex()`

Radio buttons, list boxes, and combo boxes are usually selected by index.

Indexes start at 0:

Index 0 selects the first option
Index 1 selects the second option
Index 2 selects the third option

3. Fill All Form Fields in a PDF

The following example reads every form field in a PDF and assigns a value according to the field type.

Implementation Steps

Create a PdfDocument object.
Load the PDF form with loadFromFile().
Retrieve the form through getForm().
Get the form field collection.
Iterate through the fields and determine each field type.
Assign an appropriate value to each field.
Save the completed PDF.
Close the document and release resources.

Complete Code Example

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;
import com.spire.pdf.fields.PdfField;
import com.spire.pdf.widget.PdfCheckBoxWidgetFieldWidget;
import com.spire.pdf.widget.PdfComboBoxWidgetFieldWidget;
import com.spire.pdf.widget.PdfFormFieldWidgetCollection;
import com.spire.pdf.widget.PdfFormWidget;
import com.spire.pdf.widget.PdfListBoxWidgetFieldWidget;
import com.spire.pdf.widget.PdfRadioButtonListFieldWidget;
import com.spire.pdf.widget.PdfTextBoxFieldWidget;

public class FillFormFields {

    public static void main(String[] args) {

        String inputPath = "Forms.pdf";
        String outputPath = "FillFormFields.pdf";

        // Create a PdfDocument object
        PdfDocument document = new PdfDocument();

        try {
            // Load the PDF containing form fields
            document.loadFromFile(inputPath);

            // Retrieve the PDF form
            PdfFormWidget form =
                (PdfFormWidget) document.getForm();

            // Retrieve the form field collection
            PdfFormFieldWidgetCollection fields =
                form.getFieldsWidget();

            // Iterate through and fill all form fields
            for (int i = 0; i < fields.getCount(); i++) {

                PdfField field = fields.get(i);

                // Fill a text box
                if (field instanceof PdfTextBoxFieldWidget) {
                    PdfTextBoxFieldWidget textBox =
                        (PdfTextBoxFieldWidget) field;

                    textBox.setText("Kaila Smith");
                }

                // Select the second radio button option
                else if (
                    field instanceof PdfRadioButtonListFieldWidget
                ) {
                    PdfRadioButtonListFieldWidget radioButton =
                        (PdfRadioButtonListFieldWidget) field;

                    radioButton.setSelectedIndex(1);
                }

                // Select the first item in a list box
                else if (
                    field instanceof PdfListBoxWidgetFieldWidget
                ) {
                    PdfListBoxWidgetFieldWidget listBox =
                        (PdfListBoxWidgetFieldWidget) field;

                    listBox.setSelectedIndex(0);
                }

                // Check specific checkboxes by field name
                else if (
                    field instanceof PdfCheckBoxWidgetFieldWidget
                ) {
                    PdfCheckBoxWidgetFieldWidget checkBox =
                        (PdfCheckBoxWidgetFieldWidget) field;

                    switch (checkBox.getName()) {
                        case "checkbox1":
                        case "checkbox2":
                            checkBox.setChecked(true);
                            break;

                        default:
                            break;
                    }
                }

                // Select the second item in a combo box
                else if (
                    field instanceof PdfComboBoxWidgetFieldWidget
                ) {
                    PdfComboBoxWidgetFieldWidget comboBox =
                        (PdfComboBoxWidgetFieldWidget) field;

                    comboBox.setSelectedIndex(1);
                }
            }

            // Save the completed PDF
            document.saveToFile(
                outputPath,
                FileFormat.PDF
            );

            System.out.println(
                "The PDF form was filled successfully: "
                + outputPath
            );
        } finally {
            // Close the document and release resources
            document.close();
        }
    }
}

4. Code Explanation

Load the PDF Form

PdfDocument document = new PdfDocument();
document.loadFromFile("Forms.pdf");

PdfDocument represents and processes the PDF file. The loadFromFile() method loads the source document from the specified path.

Retrieve the PDF Form Object

PdfFormWidget form =
    (PdfFormWidget) document.getForm();

The getForm() method retrieves the form object contained in the PDF.

The returned object is cast to PdfFormWidget so that the interactive field collection can be accessed.

Retrieve All Form Fields

PdfFormFieldWidgetCollection fields =
    form.getFieldsWidget();

The getFieldsWidget() method returns all interactive form fields in the PDF.

Use the following method to retrieve the number of fields:

int fieldCount = fields.getCount();

A field can then be accessed by index:

PdfField field = fields.get(i);

Determine the Field Type

Each field is represented as a PdfField, but its actual type may differ. Use instanceof to identify the concrete field type.

For example:

if (field instanceof PdfTextBoxFieldWidget) {
    PdfTextBoxFieldWidget textBox =
        (PdfTextBoxFieldWidget) field;

    textBox.setText("Kaila Smith");
}

After identifying the type, cast the field to the corresponding widget class and call the appropriate setter method.

Save the Completed PDF

document.saveToFile(
    "FillFormFields.pdf",
    FileFormat.PDF
);

Save the result to a new file so that the original PDF form remains unchanged.

5. Fill Different Values Based on Field Names

The previous example fills every text box with the same value:

textBox.setText("Kaila Smith");

In a real application, different text boxes typically represent different values, such as a name, email address, phone number, or postal address.

In that case, assign values based on the field name.

Example

if (field instanceof PdfTextBoxFieldWidget) {

    PdfTextBoxFieldWidget textBox =
        (PdfTextBoxFieldWidget) field;

    String fieldName = textBox.getName();

    switch (fieldName) {
        case "name":
            textBox.setText("Kaila Smith");
            break;

        case "email":
            textBox.setText("kaila@example.com");
            break;

        case "phone":
            textBox.setText("13800000000");
            break;

        case "address":
            textBox.setText(
                "No. 100, Example Road"
            );
            break;

        default:
            break;
    }
}

This is more reliable than filling fields by index.

If the form design changes, the order of the fields may also change. As long as the field names remain the same, name-based matching can still locate the correct fields.

6. List All PDF Form Field Names and Types

Before writing the field-filling logic, it is often useful to inspect the form and determine which fields it contains.

The following code prints the name and type of every field:

PdfFormWidget form =
    (PdfFormWidget) document.getForm();

PdfFormFieldWidgetCollection fields =
    form.getFieldsWidget();

for (int i = 0; i < fields.getCount(); i++) {

    PdfField field = fields.get(i);

    System.out.println(
        "Field index: " + i
    );

    System.out.println(
        "Field name: " + field.getName()
    );

    System.out.println(
        "Field type: "
        + field.getClass().getSimpleName()
    );

    System.out.println("--------------------");
}

Example output:

Field index: 0
Field name: name
Field type: PdfTextBoxFieldWidget
--------------------
Field index: 1
Field name: gender
Field type: PdfRadioButtonListFieldWidget
--------------------
Field index: 2
Field name: checkbox1
Field type: PdfCheckBoxWidgetFieldWidget
--------------------

This information can then be used to create accurate field-mapping rules.

7. Fill Individual PDF Form Field Types

Fill a Text Box

PdfTextBoxFieldWidget textBox =
    (PdfTextBoxFieldWidget) field;

textBox.setText("Kaila Smith");

Text boxes are commonly used for:

Names
Addresses
Phone numbers
Email addresses
Notes
Application details

Select a Radio Button

PdfRadioButtonListFieldWidget radioButton =
    (PdfRadioButtonListFieldWidget) field;

radioButton.setSelectedIndex(1);

A radio button group allows only one option to be selected.

An index of 1 selects the second option.

Check or Clear a Checkbox

PdfCheckBoxWidgetFieldWidget checkBox =
    (PdfCheckBoxWidgetFieldWidget) field;

checkBox.setChecked(true);

To clear the checkbox, pass false:

checkBox.setChecked(false);

Select an Item in a List Box

PdfListBoxWidgetFieldWidget listBox =
    (PdfListBoxWidgetFieldWidget) field;

listBox.setSelectedIndex(0);

Index 0 selects the first item in the list.

Select an Item in a Combo Box

PdfComboBoxWidgetFieldWidget comboBox =
    (PdfComboBoxWidgetFieldWidget) field;

comboBox.setSelectedIndex(1);

Index 1 selects the second item in the combo box.

8. Practical Considerations

Confirm That the PDF Contains Interactive Form Fields

Not every PDF that looks like a form actually contains interactive fields.

The following files usually cannot be filled directly through form field APIs:

Scanned PDFs
Image-based application forms
Tables made from ordinary text and lines
Flattened PDF forms

You can check the number of detected fields first:

PdfFormWidget form =
    (PdfFormWidget) document.getForm();

PdfFormFieldWidgetCollection fields =
    form.getFieldsWidget();

if (fields.getCount() == 0) {
    System.out.println(
        "No interactive form fields were found in the PDF."
    );
}

Do Not Assume That Field Indexes Are Fixed

The following code depends on field order:

PdfField field = fields.get(0);

If the form is modified, its field order may change.

For production applications, prefer matching fields by name:

if ("email".equals(field.getName())) {
    // Fill the email field
}

Validate Option Indexes

Radio buttons, list boxes, and combo boxes are selected by index. An invalid index may cause an exception or fail to select the intended option.

Before setting an index, confirm:

How many options the field contains
Which index corresponds to the required option
Whether indexing starts at 0

Save the Result as a New File

Avoid overwriting the original template:

document.saveToFile(
    "Forms_Filled.pdf",
    FileFormat.PDF
);

Keeping the original blank form makes it easier to reuse the template.

Release Resources Properly

Always close the PdfDocument, regardless of whether the operation succeeds:

PdfDocument document =
    new PdfDocument();

try {
    document.loadFromFile("Forms.pdf");

    // Fill and save the form
} finally {
    document.close();
}

This is especially important when processing many files in a batch.

9. Frequently Asked Questions

Why Does the Program Find No Form Fields?

Possible reasons include:

The PDF is a scanned image
The visible input areas are only drawn rectangles
The form has already been flattened
The file uses a special form structure
The PDF does not contain interactive fields

Print fields.getCount() to check how many fields were detected.

Why Are All Text Boxes Filled with the Same Value?

The example applies the same instruction to every PdfTextBoxFieldWidget:

textBox.setText("Kaila Smith");

In a real application, assign values according to each field name.

How Can I Fill Only One Field?

Check the field name before assigning a value:

if (
    field instanceof PdfTextBoxFieldWidget
    && "name".equals(field.getName())
) {
    PdfTextBoxFieldWidget textBox =
        (PdfTextBoxFieldWidget) field;

    textBox.setText("Kaila Smith");
}

Why Is the Wrong Combo Box Item Selected?

setSelectedIndex() uses zero-based indexing.

For example:

comboBox.setSelectedIndex(0);

selects the first item, not the second.

How Can I Clear a Checkbox?

Pass false to setChecked():

checkBox.setChecked(false);

Can Multiple PDF Forms Be Filled in a Batch?

Yes. Iterate through the PDF files in a folder, create a separate PdfDocument for each file, fill the fields, and save each result separately.

When processing files in a batch:

Close each document after processing
Generate a unique output file name
Log files that fail
Avoid overwriting the original templates

Conclusion

Java can be used to automatically read and populate interactive PDF form fields.

For production use, first inspect the available field names and types, then populate each field by name. This is more reliable than depending on field indexes, especially when the PDF form template may change.

Also confirm that the source PDF contains interactive form fields. Scanned documents, ordinary page content, and flattened forms require a different approach.

How to Convert PDF to PowerPoint (PPTX) in Java

Leon Davis — Fri, 24 Jul 2026 11:22:25 +0000

Converting PDF files to PowerPoint presentations is useful for meeting presentations, classroom materials, business reports, and content reuse.

Automating the conversion with Java eliminates the need to copy content page by page and makes it easier to integrate PDF-to-PowerPoint conversion into document management systems, batch-processing programs, or backend services. In most cases, each PDF page is converted into a corresponding PowerPoint slide.

This article covers how to:

Install the required PDF processing library in a Java project
Convert an entire PDF document to PPTX
Convert selected PDF pages to PowerPoint
Select pages by range, odd-numbered pages, or even-numbered pages
Convert multiple PDF files in a folder
Validate page indexes and release document resources correctly

PDF and PowerPoint use different page and object models. For PDFs containing complex fonts, graphics, transparency effects, or advanced layouts, review the generated slides to confirm that fonts, images, and element positions are displayed as expected.

1. Install the Required Java Library

The standard Java library does not provide built-in PDF-to-PowerPoint conversion, so a third-party PDF processing library is required.

The examples in this article use Spire.PDF for Java to load PDF files, extract pages, and export documents to PPTX. The library works without Microsoft PowerPoint installed.

Option 1: Add the JAR File Manually

Download the required JAR file from the following page:

Download Spire.PDF for Java

After downloading and extracting the package, add Spire.Pdf.jar to the project build path.

In IntelliJ IDEA, open:

File > Project Structure > Modules > Dependencies

Then add the JAR file.

In Eclipse, right-click the project and select:

Build Path > Configure Build Path > Libraries

Then add the JAR file.

Option 2: Add the Maven Dependency

For Maven projects, add the repository and dependency configuration to pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.6.4</version>
    </dependency>
</dependencies>

Environment Requirements

JDK 1.8 or later
IntelliJ IDEA, Eclipse, or another Java development environment

2. Convert an Entire PDF to PowerPoint

To convert a complete PDF document, load the source file with loadFromFile() and save it as PPTX with saveToFile().

Each page in the PDF is converted into a corresponding PowerPoint slide.

Implementation Steps

Create a PdfDocument object.
Load the source PDF with loadFromFile().
Call saveToFile().
Set the target format to FileFormat.PPTX.
Close the document after conversion.

Complete Code Example

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;

public class PDFtoPowerPoint {
    public static void main(String[] args) {

        PdfDocument pdfDocument = new PdfDocument();

        try {
            // Load the PDF document
            pdfDocument.loadFromFile("sample.pdf");

            // Save the entire PDF as a PPTX file
            pdfDocument.saveToFile(
                "PDFtoPowerPoint.pptx",
                FileFormat.PPTX
            );

            System.out.println(
                "The PDF was successfully converted to PowerPoint."
            );
        } finally {
            // Close the document and release resources
            pdfDocument.close();
        }
    }
}

Code Explanation

Class or method	Description
`PdfDocument`	Represents the loaded PDF and provides access to document processing and conversion features
`loadFromFile("sample.pdf")`	Loads the source PDF from the specified path
`saveToFile(..., FileFormat.PPTX)`	Converts the current PDF to PPTX and saves it
`FileFormat.PPTX`	Specifies PowerPoint PPTX as the output format
`close()`	Closes the document and releases associated resources

After the code runs, each page in sample.pdf becomes a slide in PDFtoPowerPoint.pptx.

3. Convert Selected PDF Pages to PowerPoint

In some workflows, only certain pages need to be converted rather than the complete PDF.

One approach is to create a new PDF document, add the required pages to it, and then save the new document as PPTX.

This is useful when you need to:

Extract key sections from a long PDF
Convert selected report pages
Select pages according to business rules
Rearrange pages before generating the presentation

Implementation Steps

Load the source PDF.
Create a new empty PdfDocument.
Retrieve the required pages by index.
Add the selected pages to the new document.
Save the new document as PPTX.
Close both the source and destination documents.

Note: Page indexes start at 0. For example, index 0 refers to page 1, while index 2 refers to page 3.

Complete Code Example

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;

public class PDFSpecificPagesToPPTX {
    public static void main(String[] args) {

        PdfDocument sourcePdf = new PdfDocument();
        PdfDocument newPdf = new PdfDocument();

        try {
            // Load the source PDF
            sourcePdf.loadFromFile("sample.pdf");

            // Specify the page indexes to extract
            // This example extracts pages 1, 3, and 5
            int[] pagesToExtract = {0, 2, 4};

            for (int pageIndex : pagesToExtract) {
                // Retrieve the selected page
                PdfPageBase page =
                    sourcePdf.getPages().get(pageIndex);

                // Add the page to the new document
                newPdf.getPages().add(page);
            }

            // Convert the selected pages to PPTX
            newPdf.saveToFile(
                "SelectedPagesToPPTX.pptx",
                FileFormat.PPTX
            );

            System.out.println(
                "The selected pages were converted successfully. "
                + pagesToExtract.length
                + " pages were processed."
            );
        } finally {
            sourcePdf.close();
            newPdf.close();
        }
    }
}

Key Methods

Method	Description
`sourcePdf.getPages().get(pageIndex)`	Retrieves a page from the source PDF by index
`newPdf.getPages().add(page)`	Adds the retrieved page to the new PDF document
`newPdf.saveToFile(..., FileFormat.PPTX)`	Saves the document containing the selected pages as PPTX

4. Convert Pages by Range, Odd Numbers, or Even Numbers

Instead of listing page indexes individually, a loop can be used to select a continuous range, all pages, odd-numbered pages, or even-numbered pages.

Convert a Continuous Page Range

The following example converts pages 2 through 5:

int startPage = 1;  // Page 2
int endPage = 4;    // Page 5

for (int i = startPage; i <= endPage; i++) {
    PdfPageBase page =
        sourcePdf.getPages().get(i);

    newPdf.getPages().add(page);
}

In production code, validate the page range first to avoid accessing an index outside the document:

int pageCount =
    sourcePdf.getPages().getCount();

if (
    startPage < 0
    || endPage >= pageCount
    || startPage > endPage
) {
    throw new IllegalArgumentException(
        "The specified page range is invalid."
    );
}

Convert Odd-Numbered Pages

Pages 1, 3, and 5 correspond to indexes 0, 2, and 4:

for (
    int i = 0;
    i < sourcePdf.getPages().getCount();
    i += 2
) {
    PdfPageBase page =
        sourcePdf.getPages().get(i);

    newPdf.getPages().add(page);
}

Convert Even-Numbered Pages

Pages 2, 4, and 6 correspond to indexes 1, 3, and 5:

for (
    int i = 1;
    i < sourcePdf.getPages().getCount();
    i += 2
) {
    PdfPageBase page =
        sourcePdf.getPages().get(i);

    newPdf.getPages().add(page);
}

5. Practical Considerations

Validate Page Indexes

Before retrieving selected pages, confirm that every index is within the document page count. Otherwise, the program may stop with an index-out-of-range error.

int pageCount =
    sourcePdf.getPages().getCount();

for (int pageIndex : pagesToExtract) {
    if (
        pageIndex < 0
        || pageIndex >= pageCount
    ) {
        throw new IllegalArgumentException(
            "Invalid page index: " + pageIndex
        );
    }
}

To skip invalid indexes rather than stop the entire conversion, log the issue and continue:

for (int pageIndex : pagesToExtract) {
    if (
        pageIndex < 0
        || pageIndex >= pageCount
    ) {
        System.out.println(
            "Skipped invalid page index: "
            + pageIndex
        );
        continue;
    }

    PdfPageBase page =
        sourcePdf.getPages().get(pageIndex);

    newPdf.getPages().add(page);
}

Save the Result with a New File Name

Save the converted presentation under a new file name to avoid overwriting an existing output file.

String outputPath =
    "output/PDFtoPowerPoint.pptx";

Before saving, confirm that the output directory exists:

import java.io.File;

File outputDirectory =
    new File("output");

if (!outputDirectory.exists()) {
    outputDirectory.mkdirs();
}

Release Document Resources

For batch-conversion tasks, close each document object after processing to prevent unnecessary memory usage.

A try-finally block ensures that close() is called even if loading or conversion fails.

PdfDocument document =
    new PdfDocument();

try {
    document.loadFromFile("sample.pdf");

    document.saveToFile(
        "output.pptx",
        FileFormat.PPTX
    );
} finally {
    document.close();
}

Verify the Conversion Result

PDF and PowerPoint use different document models. After conversion, review the output for:

Correct font rendering
Complete images and graphics
Expected slide dimensions
Correct positioning of text, tables, and other elements
Accurate reproduction of complex layouts
Correct page order

PDFs containing embedded fonts, transparent objects, complex vector graphics, or special layers may produce different results depending on the source document and runtime environment.

Convert Multiple PDF Files in a Folder

To process an entire folder, enumerate the PDF files and create a separate PdfDocument instance for each file.

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;

import java.io.File;

public class BatchPDFtoPowerPoint {
    public static void main(String[] args) {

        File inputFolder =
            new File("C:/InputPDF");

        File outputFolder =
            new File("C:/OutputPPTX");

        if (!inputFolder.exists()) {
            System.out.println(
                "The input folder does not exist."
            );
            return;
        }

        if (!outputFolder.exists()
            && !outputFolder.mkdirs()) {
            System.out.println(
                "The output folder could not be created."
            );
            return;
        }

        File[] files =
            inputFolder.listFiles(
                (dir, name) ->
                    name.toLowerCase()
                        .endsWith(".pdf")
            );

        if (files == null
            || files.length == 0) {
            System.out.println(
                "No PDF files were found."
            );
            return;
        }

        for (File file : files) {
            PdfDocument document =
                new PdfDocument();

            try {
                document.loadFromFile(
                    file.getAbsolutePath()
                );

                String outputName =
                    file.getName().replaceAll(
                        "(?i)\\.pdf$",
                        ".pptx"
                    );

                File outputFile =
                    new File(
                        outputFolder,
                        outputName
                    );

                document.saveToFile(
                    outputFile.getAbsolutePath(),
                    FileFormat.PPTX
                );

                System.out.println(
                    "Converted: " + file.getName()
                );
            } catch (Exception ex) {
                System.out.println(
                    "Failed to convert "
                    + file.getName()
                    + ": "
                    + ex.getMessage()
                );
            } finally {
                document.close();
            }
        }
    }
}

6. Frequently Asked Questions

Can the Converted PowerPoint File Be Edited?

The output is a PPTX file and can be opened in Microsoft PowerPoint or another compatible application.

However, whether each element can be edited like a native PowerPoint object depends on the structure of the source PDF and the conversion result. Some content may be represented as images, text boxes, or grouped objects.

Why Do Fonts Change After Conversion?

If the source PDF uses a font that is not installed in the runtime environment or on the computer opening the PPTX file, the system may substitute another font.

Install the required fonts where possible and review the text layout after conversion.

How Many Slides Are Generated from One PDF Page?

In most cases, one PDF page is converted into one PowerPoint slide.

How Can I Convert Only the First Page?

Retrieve the page at index 0 and add it to a new PDF document:

PdfPageBase page =
    sourcePdf.getPages().get(0);

newPdf.getPages().add(page);

Then save the new document as PPTX:

newPdf.saveToFile(
    "FirstPage.pptx",
    FileFormat.PPTX
);

How Can I Check Whether a PDF Contains Any Pages?

Check the page count after loading the document:

int pageCount =
    sourcePdf.getPages().getCount();

if (pageCount == 0) {
    System.out.println(
        "The PDF does not contain any pages to convert."
    );
    return;
}

Is Microsoft PowerPoint Required?

No. The code shown in this article does not depend on Microsoft PowerPoint and can run in an environment where PowerPoint is not installed.

Conclusion

Java can be used to automate PDF-to-PowerPoint conversion for both complete documents and selected pages.

For a complete PDF, call saveToFile() and specify FileFormat.PPTX. When only certain pages are required, add those pages to a new document and convert the resulting document instead.

The same API also supports converting PDF documents to Word, Excel, HTML, images, and other formats.

Set Font Color in Word Documents with Java: 3 Ways

Leon Davis — Fri, 17 Jul 2026 11:52:57 +0000

Coloring text programmatically comes up more than you'd expect once you're generating or post-processing Word files from Java — flagging changed clauses in a contract, marking up review comments, or just making a generated report easier to skim. There's more than one way to do it, and which one you reach for depends on whether you're coloring a whole paragraph, a specific run of text, or every occurrence of a keyword across the document. Here's how each one works, and a couple of things that aren't obvious until you hit them.

Setup

The examples below use Spire.Doc for Java. With Maven, add the dependency to pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.doc</artifactId>
        <version>13.5.3</version>
    </dependency>
</dependencies>

If you're not on Maven, the jar can also be downloaded directly from the official website and added to the classpath.

Method 1: Coloring an entire paragraph via a style

If you want to recolor everything in a paragraph at once, the cleanest way is to define a ParagraphStyle with the color you want and apply it to the paragraph.

import com.spire.doc.Document;
import com.spire.doc.FileFormat;
import com.spire.doc.Section;
import com.spire.doc.documents.Paragraph;
import com.spire.doc.documents.ParagraphStyle;

import java.awt.*;

public class ColorWholeParagraph {
    public static void main(String[] args) {
        Document document = new Document();
        document.loadFromFile("report.docx");

        Section section = document.getSections().get(0);
        Paragraph paragraph = section.getParagraphs().get(0);

        ParagraphStyle style = new ParagraphStyle(document);
        style.setName("HighlightRed");
        style.getCharacterFormat().setTextColor(new Color(178, 34, 34));

        document.getStyles().add(style);
        paragraph.applyStyle(style.getName());

        document.saveToFile("output/colored.docx", FileFormat.Docx);
    }
}

This is the right tool when the whole paragraph should look consistent and you're not fighting existing run-level formatting. Which brings up the first gotcha: applying a paragraph style doesn't override formatting that's already set directly on the runs inside it. Word (and Spire.Doc, following the same model) treats direct/run-level formatting as taking priority over whatever the paragraph's style says. So if some of the text in that paragraph already has an explicit color set — maybe from a previous edit, or because it was pasted in with its own formatting — applyStyle() alone won't touch it, and you'll end up with a paragraph that's only partially recolored. If you need to guarantee every character changes, Method 2 below is more reliable.

Method 2: Coloring runs directly

A paragraph's text is stored as a sequence of child objects, and the actual text lives in TextRange objects mixed in with other elements like line breaks or inline images. Looping through them and setting the color on each TextRange sidesteps the style-precedence issue entirely, since you're changing the direct formatting itself.

import com.spire.doc.Document;
import com.spire.doc.Section;
import com.spire.doc.documents.Paragraph;
import com.spire.doc.fields.TextRange;
import com.spire.doc.FileFormat;

import java.awt.*;

public class ColorParagraphRuns {
    public static void main(String[] args) {
        Document document = new Document();
        document.loadFromFile("report.docx");

        Section section = document.getSections().get(0);
        Paragraph paragraph = section.getParagraphs().get(1);

        for (int i = 0; i < paragraph.getChildObjects().getCount(); i++) {
            if (paragraph.getChildObjects().get(i) instanceof TextRange) {
                TextRange run = (TextRange) paragraph.getChildObjects().get(i);
                run.getCharacterFormat().setTextColor(Color.blue);
            }
        }

        document.saveToFile("output/coloredRuns.docx", FileFormat.Docx);
    }
}

This is a bit more verbose than the style-based approach, but it's the one to reach for when you can't assume the paragraph is formatting-clean, which in practice is most of the time with documents that have already been edited by a human.

Method 3: Coloring every occurrence of a specific phrase

Sometimes the target isn't a paragraph at all — it's a word or phrase that might show up anywhere in the document. findAllString() returns every match as a TextSelection, and each one can be turned into a formattable range.

import com.spire.doc.Document;
import com.spire.doc.FileFormat;
import com.spire.doc.documents.TextSelection;
import com.spire.doc.fields.TextRange;

import java.awt.*;

public class ColorMatchedText {
    public static void main(String[] args) {
        Document document = new Document();
        document.loadFromFile("report.docx");

        TextSelection[] matches = document.findAllString("Confidential", false, true);

        for (TextSelection match : matches) {
            TextRange range = match.getAsOneRange();
            range.getCharacterFormat().setTextColor(Color.red);
        }

        document.saveToFile("output/coloredMatches.docx", FileFormat.Docx);
    }
}

The getAsOneRange() call matters more than it looks. A phrase that appears as one visible word or sentence in Word isn't guaranteed to be stored as a single TextRange internally — spell-check state, tracked changes, or just how the original document was authored can split it into several adjacent runs. getAsOneRange() merges whatever runs made up that particular match into a single range so you can format it as one unit, rather than ending up with only part of the phrase changing color because you only touched the first run.

A couple of general notes

Colors are plain java.awt.Color objects, so anything that works there — named constants like Color.red, or explicit RGB via new Color(r, g, b) — works here too. And findAllString() takes two boolean flags after the search string (case sensitivity and whole-word matching); worth double-checking those against your actual search term, since a whole-word match on something like "PDF" won't catch it inside "PDFs" or "PDF-2".

Between the three, style-based coloring is the fastest to write when you control how the document was built, direct run coloring is the one that actually works when you don't, and text search is for anything keyword-driven rather than position-driven. Picking the right one up front saves having to debug why only half a paragraph changed color.

Delete, Reorder, Rotate, and Crop PDF Pages in Java

Leon Davis — Fri, 17 Jul 2026 11:35:05 +0000

Page-level PDF editing — removing extra pages, reordering pages, fixing pages with the wrong orientation, or cropping out unwanted margins — comes up pretty often in day-to-day development. It sounds simple, but once you actually write the code, index shifting and coordinate system direction are the kind of details that trip people up. This post walks through the implementation for each of these operations with Java code examples.

Setup

The library used here is Spire.PDF for Java. If you're using Maven, add the following to your pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.7.0</version>
    </dependency>
</dependencies>

If you're not using Maven, you can also download the jar directly from the vendor's site and add it to your project manually.

Once the dependency is in place, pretty much everything page-related revolves around the PdfDocument class and its getPages() collection. Let's go through each operation.

1. Deleting Pages

Deleting a page is the most common operation. Use PdfDocument.getPages().removeAt(int index), passing in the zero-based index of the page you want to remove.

import com.spire.pdf.PdfDocument;

public class DeletePage {
    public static void main(String[] args) {
        // Create a PdfDocument instance
        PdfDocument pdf = new PdfDocument();
        // Load the PDF document
        pdf.loadFromFile("sample.pdf");
        // Remove the second page (index is zero-based, so 1 means the second page)
        pdf.getPages().removeAt(1);
        // Save the result
        pdf.saveToFile("output/deletePage.pdf");
        pdf.close();
    }
}

Page indices start at 0, which is easy to mix up with the "page 1 = first page" convention people usually think in — worth double-checking the index before you run this. The deletion is also irreversible, so back up the original file first.

If you need to delete multiple pages at once, delete from the highest index to the lowest. Say you want to remove pages 2, 4, and 6: if you iterate forward and delete as you go, once page 2 is gone, the old page 4 shifts into page 3's slot, and continuing with the original indices ends up deleting the wrong pages.

int[] pagesToDelete = {1, 3, 5}; // corresponds to pages 2, 4, 6
Arrays.sort(pagesToDelete);
for (int i = pagesToDelete.length - 1; i >= 0; i--) {
    pdf.getPages().removeAt(pagesToDelete[i]);
}

2. Reordering Pages

When page order is scrambled, use PdfDocument.getPages().reArrange() to fix it in one shot. It takes an int[] array where each element is the original page index, and the array's order becomes the new page order.

import com.spire.pdf.PdfDocument;

public class RearrangePages {
    public static void main(String[] args) {
        // Create a PdfDocument instance
        PdfDocument doc = new PdfDocument();
        // Load the PDF document
        doc.loadFromFile("input.pdf");
        // Reorder pages: original page 1, 3, 2, 4
        doc.getPages().reArrange(new int[]{0, 2, 1, 3});
        // Save the result
        doc.saveToFile("output/rearranged.pdf");
        doc.close();
    }
}

3. Rotating Pages

Scanned PDFs frequently end up with the wrong orientation. Rotation works in 90-degree increments — 0°, 90°, 180°, or 270° — set via PdfPageBase.setRotation().

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.PdfPageRotateAngle;

public class RotatePdfPage {
    public static void main(String[] args) {
        // Create a PdfDocument instance
        PdfDocument pdf = new PdfDocument();
        // Load the PDF document
        pdf.loadFromFile("sample.pdf");
        // Get the first page
        PdfPageBase page = pdf.getPages().get(0);
        // Get the current rotation angle
        int rotation = page.getRotation().getValue();
        // Rotate 180 degrees on top of the existing angle
        rotation += PdfPageRotateAngle.Rotate_Angle_180.getValue();
        page.setRotation(PdfPageRotateAngle.fromValue(rotation));
        // Save the result
        pdf.saveToFile("output/rotated.pdf");
        pdf.close();
    }
}

Note that this adds to the existing rotation angle rather than overwriting it. Scanned files often already carry a rotation value of their own (PDFs generated from phone photos default to 270 degrees quite often), so if you skip reading the original angle and just assign a new one directly, the displayed result won't match what you expect.

To rotate every page, just loop through the pdf.getPages() collection and apply the same logic to each one:

for (int i = 0; i < pdf.getPages().getCount(); i++) {
    PdfPageBase page = pdf.getPages().get(i);
    int rotation = page.getRotation().getValue();
    rotation += PdfPageRotateAngle.Rotate_Angle_90.getValue();
    page.setRotation(PdfPageRotateAngle.fromValue(rotation));
}

4. Cropping Pages

Cropping works by modifying the page's CropBox, which defines the visible area of the page — anything outside it simply won't render. Use PdfPageBase.setCropBox(Rectangle2D rect) to set it.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import java.awt.geom.Rectangle2D;

public class CropPdfPage {
    public static void main(String[] args) {
        // Create a PdfDocument instance
        PdfDocument pdf = new PdfDocument();
        // Load the PDF document
        pdf.loadFromFile("example.pdf");
        // Get the first page
        PdfPageBase page = pdf.getPages().get(0);
        // Define the crop area: x, y, width, height
        Rectangle2D rect = new Rectangle2D.Float(0, 0, 550, 822);
        // Apply the crop box
        page.setCropBox(rect);
        // Save the result
        pdf.saveToFile("output/cropped.pdf");
        pdf.close();
    }
}

All four Rectangle2D.Float parameters are in points. There's one gotcha worth calling out on its own: Spire.PDF's coordinate system is not the same as the native PDF spec. The PDF spec places the origin at the bottom-left of the page with the y-axis pointing up. Spire.PDF, to make top-down positioning more intuitive for programmers, remaps that to an origin at the top-left with the y-axis pointing down. setCropBox follows this same remapped system: x and y are the offset of the crop area's top-left corner from the page's top-left corner, and width/height extend right and downward from there.

So to crop out a black margin at the top of the page, you just set y to the margin height directly — no need to work backward from the total page height. For a 20pt margin at the top, that's new Rectangle2D.Float(0, 20, width, height - 20) — starting 20pt down from the top and extending down to the bottom of the page skips right past that margin. Assuming the origin is bottom-left, the way the raw PDF spec defines it, gets the direction backwards — you'll typically end up with either the margin still sitting there or a chunk of your content cut off.

One more thing worth noting: setCropBox only changes the visible region — the original content is still fully intact in the file, just not rendered outside the crop box. That means it's not a real deletion. If you're trying to redact sensitive information from a page, cropping isn't the right tool for that.

Summary

This article showed how to remove, reorder, rotate and crop pages in PDF. Use removeAt() for deleting pages, reArrange() for reordering, setRotation() for rotating, and setCropBox() for cropping. A few things worth keeping in mind: delete pages from the end backward when removing multiple at once; rotation angles accumulate rather than get overwritten; and the crop coordinate system is Spire.PDF's own remapped one — origin at the top-left, y-axis pointing down — which is the opposite of what the native PDF spec defines, even though it happens to be what you'd normally expect from a graphics API. Keeping these in mind up front saves a fair bit of debugging time later.

Parse PDF in Java: Extract Text, Tables, Images, and Metadata

Leon Davis — Fri, 10 Jul 2026 10:51:39 +0000

PDFs look straightforward until you need to extract something from them.

A page that appears to contain normal paragraphs and tables may internally be made up of positioned glyphs, embedded images, drawing commands, and metadata objects. As a result, reliable PDF parsing usually requires more than simply “reading the file.”

In a typical Java application, PDF parsing may involve several separate tasks:

Loading the document and checking that it can be processed
Extracting text page by page
Detecting and reading tables
Exporting embedded images
Reading document metadata

This guide shows how to handle each task with Java. The examples are intentionally separated so that you can use only the parts your project needs or combine them into a larger document-processing pipeline.

1. Install the Required Library

The examples below use Spire.PDF for Java because it provides dedicated APIs for text, table, image, and metadata extraction.

For a Maven project, add the e-iceblue repository and dependency to your pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.7.0</version>
    </dependency>
</dependencies>

If you are not using Maven, download the JAR package from the official website and add the required files to your project classpath.

Before using the library in a production application, review its licensing terms and choose a version that is compatible with your Java environment.

2. Load a PDF and Check Its Page Count

Before extracting any content, first confirm that the library can open the document and access its page collection.

This is not a complete PDF validation test, but it is a useful early check for unreadable, corrupted, encrypted, or unsupported files.

import com.spire.pdf.PdfDocument;

public class LoadPdf {
    public static void main(String[] args) {
        PdfDocument pdf = new PdfDocument();

        try {
            pdf.loadFromFile("sample.pdf");

            int pageCount = pdf.getPages().getCount();
            System.out.println("Total pages: " + pageCount);
        } finally {
            pdf.close();
        }
    }
}

If the file loads successfully, the application can at least read the document structure and access its page tree.

In a batch-processing system, this step can act as an initial gate. Files that cannot be opened can be logged or moved to a review queue before more expensive extraction operations begin.

For production code, also add exception handling for cases such as:

Missing files
Password-protected PDFs
Unsupported encryption
Damaged document structures
Permission or file-locking errors

3. Extract Text from Every PDF Page

Text extraction is one of the most common PDF parsing tasks. It is useful for search indexing, document analysis, content migration, summarization, and archiving.

Unlike a plain text file, however, a PDF does not necessarily store text as continuous paragraphs. Individual characters may be placed at specific coordinates on the page. The extraction library must reconstruct the reading order from those positions.

The following example extracts text one page at a time:

import com.spire.pdf.PdfDocument;
import com.spire.pdf.texts.PdfTextExtractOptions;
import com.spire.pdf.texts.PdfTextExtractor;

public class ExtractPdfText {
    public static void main(String[] args) {
        PdfDocument pdf = new PdfDocument();

        try {
            pdf.loadFromFile("sample.pdf");

            StringBuilder extractedText = new StringBuilder();

            PdfTextExtractOptions options = new PdfTextExtractOptions();

            // Produce a simpler reading flow instead of preserving
            // every element's exact visual position.
            options.setSimpleExtraction(true);

            for (int i = 0; i < pdf.getPages().getCount(); i++) {
                PdfTextExtractor extractor =
                        new PdfTextExtractor(pdf.getPages().get(i));

                String pageText = extractor.extract(options);

                extractedText
                        .append("Page ")
                        .append(i + 1)
                        .append(System.lineSeparator())
                        .append(pageText)
                        .append(System.lineSeparator())
                        .append(System.lineSeparator());
            }

            System.out.println(extractedText);
        } finally {
            pdf.close();
        }
    }
}

A few details are worth noting:

PdfTextExtractor works on one page at a time.
Page-level processing makes it easier to identify pages with extraction problems.
setSimpleExtraction(true) can produce a more natural reading flow, although it may flatten some visual layout information.
Processing documents page by page can also make large files easier to manage.

The result still depends on how the original PDF was created. Multi-column pages, unusual font encodings, floating text boxes, or heavily positioned content may not be returned in the expected reading order.

Scanned PDFs are a separate case. If a page contains only an image and no selectable text layer, regular text extraction will usually return little or no content. OCR must be applied before or during processing.

4. Extract Tables from a PDF

Tables are common in invoices, financial statements, product catalogs, and operational reports. They are also more difficult to parse than ordinary text.

A PDF does not always store a table as an actual table object. In many documents, the table is simply a collection of text fragments and lines positioned to look like rows and columns.

PdfTableExtractor analyzes the page layout and attempts to reconstruct that structure.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.utilities.PdfTable;
import com.spire.pdf.utilities.PdfTableExtractor;

public class ExtractPdfTables {
    public static void main(String[] args) {
        PdfDocument pdf = new PdfDocument();

        try {
            pdf.loadFromFile("sample.pdf");

            PdfTableExtractor extractor = new PdfTableExtractor(pdf);

            // Extract tables from the first page.
            PdfTable[] tables = extractor.extractTable(0);

            if (tables == null || tables.length == 0) {
                System.out.println("No tables found.");
                return;
            }

            for (int tableIndex = 0; tableIndex < tables.length; tableIndex++) {
                PdfTable table = tables[tableIndex];

                int rowCount = table.getRowCount();
                int columnCount = table.getColumnCount();

                System.out.println(
                        "Table " + (tableIndex + 1)
                                + ": " + rowCount + " rows, "
                                + columnCount + " columns"
                );

                StringBuilder output = new StringBuilder();

                for (int row = 0; row < rowCount; row++) {
                    for (int column = 0; column < columnCount; column++) {
                        String cellText = table.getText(row, column);

                        if (cellText != null) {
                            cellText = cellText
                                    .replace("\r", " ")
                                    .replace("\n", " ")
                                    .trim();
                        }

                        output.append(cellText == null ? "" : cellText);

                        if (column < columnCount - 1) {
                            output.append('\t');
                        }
                    }

                    output.append(System.lineSeparator());
                }

                System.out.println(output);
            }
        } finally {
            pdf.close();
        }
    }
}

This example prints the extracted cells as tab-separated values. In a real application, you might instead:

Export the data to CSV
Convert it to JSON
Insert it into a database
Map rows to Java objects
Send it to an analytics pipeline

Table extraction works best when the source document has regular rows, consistent columns, and clear spacing or borders.

Results may require cleanup when a table contains:

Merged cells
Nested tables
Multi-line headers
Irregular column widths
Missing borders
Text that overlaps cell boundaries

Header rows are not always identified automatically. If your application needs to distinguish headers from data rows, add validation or document-specific rules after extraction.

5. Export Images Embedded in PDF Pages

Image extraction can be useful for archiving, auditing, document migration, or separating visual assets from the surrounding text.

The following example finds raster images on each page and saves them as PNG files:

import com.spire.pdf.PdfDocument;
import com.spire.pdf.utilities.PdfImageHelper;
import com.spire.pdf.utilities.PdfImageInfo;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ExtractPdfImages {
    public static void main(String[] args) throws IOException {
        PdfDocument pdf = new PdfDocument();

        try {
            pdf.loadFromFile("sample.pdf");

            File outputDirectory = new File("images");

            if (!outputDirectory.exists() && !outputDirectory.mkdirs()) {
                throw new IOException(
                        "Could not create output directory: "
                                + outputDirectory.getAbsolutePath()
                );
            }

            PdfImageHelper imageHelper = new PdfImageHelper();

            for (int pageIndex = 0;
                 pageIndex < pdf.getPages().getCount();
                 pageIndex++) {

                PdfImageInfo[] imageInfo =
                        imageHelper.getImagesInfo(
                                pdf.getPages().get(pageIndex)
                        );

                if (imageInfo == null || imageInfo.length == 0) {
                    continue;
                }

                for (int imageIndex = 0;
                     imageIndex < imageInfo.length;
                     imageIndex++) {

                    BufferedImage image =
                            imageInfo[imageIndex].getImage();

                    File outputFile = new File(
                            outputDirectory,
                            "page_" + (pageIndex + 1)
                                    + "_image_" + (imageIndex + 1)
                                    + ".png"
                    );

                    ImageIO.write(image, "PNG", outputFile);

                    System.out.println(
                            "Saved: " + outputFile.getPath()
                    );
                }
            }
        } finally {
            pdf.close();
        }
    }
}

A few practical limitations apply:

Logos, backgrounds, and decorative graphics may also be returned.
Very large images can consume significant memory.
The extracted color space or compression may differ from the original asset.
Vector drawings are not necessarily returned as raster images.
A single visual illustration may be composed of several separate resources.

If you only need certain images, consider filtering the results by dimensions, file size, page location, or other available metadata.

For large batch jobs, process one page at a time and avoid keeping unnecessary BufferedImage instances in memory.

6. Read PDF Metadata

PDF metadata may include the document title, author, subject, keywords, creator application, producer, and creation or modification dates.

Reading this information is inexpensive because it does not require iterating through every page.

import com.spire.pdf.PdfDocument;

public class ReadPdfMetadata {
    public static void main(String[] args) {
        PdfDocument pdf = new PdfDocument();

        try {
            pdf.loadFromFile("sample.pdf");

            System.out.println(
                    "Title: "
                            + pdf.getDocumentInformation().getTitle()
            );
            System.out.println(
                    "Author: "
                            + pdf.getDocumentInformation().getAuthor()
            );
            System.out.println(
                    "Subject: "
                            + pdf.getDocumentInformation().getSubject()
            );
            System.out.println(
                    "Keywords: "
                            + pdf.getDocumentInformation().getKeywords()
            );
            System.out.println(
                    "Creator: "
                            + pdf.getDocumentInformation().getCreator()
            );
            System.out.println(
                    "Producer: "
                            + pdf.getDocumentInformation().getProducer()
            );
            System.out.println(
                    "Creation date: "
                            + pdf.getDocumentInformation().getCreationDate()
            );
            System.out.println(
                    "Modification date: "
                            + pdf.getDocumentInformation().getModificationDate()
            );
        } finally {
            pdf.close();
        }
    }
}

Do not assume that metadata is complete or trustworthy.

Some documents contain no metadata, while others contain outdated or automatically generated values. A PDF may also claim an author or creation date that does not reflect the actual source of the document.

Treat metadata as a useful classification signal rather than definitive proof about a file's origin.

In a document-processing system, metadata can help with:

Routing documents to different workflows
Building search indexes
Applying naming conventions
Detecting likely duplicates
Organizing files by author or date

Always handle missing values before storing or displaying them.

7. Build a Maintainable Parsing Pipeline

In a real application, these operations are usually more useful when combined into a pipeline.

A typical workflow might look like this:

Verify that the file exists and can be opened.
Read metadata for classification or routing.
Determine whether the PDF has a usable text layer.
Extract text page by page.
Detect and export tables where needed.
Export relevant images.
Store the results in a database, search index, or file system.
Send failed or low-confidence documents for review.

Keeping these stages separate has several advantages. A failure during table extraction does not have to prevent metadata or text extraction, and each stage can be tested, logged, or replaced independently.

A simple domain model might store the result like this:

public class ParsedPdf {
    private String title;
    private String author;
    private String text;
    private int pageCount;

    // Add table, image, error, and page-level result fields as needed.
}

For larger systems, consider keeping page-level results instead of combining the entire document into one large string. That makes it easier to:

Trace extracted content back to a page
Retry only failed pages
Build page-aware search results
Process documents in parallel
Limit memory usage

Common PDF Parsing Limitations

Even with a dedicated library, PDF parsing is not always predictable.

Scanned or image-only PDFs

If the PDF has no selectable text layer, regular text and table extraction will not work reliably. Use OCR, such as Tesseract or another OCR service, before applying text-based parsing.

Complex page layouts

Multiple columns, floating elements, borderless tables, merged cells, and irregular spacing can affect reading order and table detection.

For highly structured document types, a document-specific parser may produce better results than a completely generic pipeline.

Font encoding issues

Some PDFs use custom font encodings or incomplete character maps. This can result in missing characters, incorrect symbols, or unreadable output.

Trying different text extraction settings may help, but some files will still require OCR or manual correction.

Memory usage

Large PDFs and high-resolution images can use substantial memory. Process documents page by page, release references as soon as possible, and avoid loading unnecessary image data.

Error handling

A production parser should expect individual files or pages to fail. Log enough context to identify the source file, page number, and failed operation without stopping an entire batch unnecessarily.

Resource cleanup

Always call pdf.close() after processing. This releases file handles and native resources, which is especially important when processing many files in a long-running service.

How to Edit PDF in Java: Step-by-Step Guide

Leon Davis — Fri, 10 Jul 2026 10:22:33 +0000

Editing PDF documents programmatically involves a wide range of tasks: inserting new pages, adding text and images, replacing existing content, removing unwanted elements, and applying security measures like watermarks and encryption. In this post, I’ll share practical Java code snippets for each of these common editing scenarios, based on my recent project experience.

1. Environment Setup

Before diving into code, you need to include a PDF library in your project. I chose Spire.PDF for Java because of its rich API and ease of use. If you are using Maven, add the following repository and dependency to your pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>11.9.6</version>
    </dependency>
</dependencies>

If you are not using Maven, download the JAR package from the official website and add it to your project’s classpath.

2. Loading a Document

All operations start with loading an existing PDF file into a PdfDocument object:

PdfDocument doc = new PdfDocument();
doc.loadFromFile("C:\\work\\sample.pdf");

The loadFromFile method accepts a file path (absolute or relative). Once loaded, the document is ready for manipulation.

3. Adding Content

3.1 Adding a Page

To append a new page at the end of the document, use getPages().add():

PdfPageBase newPage = doc.getPages().add(PdfPageSize.A4, new PdfMargins(54));
newPage.getCanvas().drawString("This is the newly added page.",
    new PdfTrueTypeFont(new Font("Arial", Font.PLAIN, 18)),
    PdfBrushes.getBlue(), 0, 0);

This creates an A4 page with 54‑point margins on both sides and draws blue text at the top‑left corner.

3.2 Adding Text on an Existing Page

If you need to place text within a specific rectangular area (with automatic line wrapping), define a Rectangle2D.Float:

PdfPageBase page = doc.getPages().get(0);
Rectangle2D.Float rect = new Rectangle2D.Float(54, 300, 400, 100);
PdfTrueTypeFont font = new PdfTrueTypeFont(new Font("Times New Roman", Font.PLAIN, 14));
PdfSolidBrush brush = new PdfSolidBrush(new PdfRGBColor(Color.BLACK));
page.getCanvas().drawString("This text will be drawn inside the defined rectangle and wraps automatically.", font, brush, rect);

The text will fit within the rectangle, making it ideal for filling form fields or adding annotations.

3.3 Inserting an Image

Inserting an image (e.g., logo or signature) is straightforward:

PdfImage image = PdfImage.fromFile("C:\\work\\logo.png");
page.getCanvas().drawImage(image, 100, 500);

fromFile loads the image, and drawImage places it at the specified (x, y) coordinates. You can also scale the image by using an overload that accepts width and height.

3.4 Adding a Table

Tables are essential for data presentation. Spire.PDF can generate a table directly from a two‑dimensional array:

PdfTable table = new PdfTable();
String[][] data = {
    {"Name", "Department", "Year"},
    {"Alice", "R&D", "2019"},
    {"Bob", "Marketing", "2020"},
    {"Charlie", "Finance", "2018"}
};
table.setDataSource(data);
// Customise table style
PdfTableStyle style = new PdfTableStyle();
style.getDefaultStyle().setFont(new PdfTrueTypeFont(new Font("Arial", Font.PLAIN, 12)));
table.setStyle(style);
// Draw the table on the page
table.draw(page, new Point2D.Float(50, 200));

setDataSource accepts the data, and draw places the table at the given top‑left position. You can further customise borders, background, and font.

3.5 Adding an Annotation

Popup annotations improve interactivity—for example, adding a comment or reminder:

PdfPopupAnnotation popup = new PdfPopupAnnotation();
popup.setLocation(new Point2D.Double(200, 400));
popup.setText("Please verify these figures.");
popup.setIcon(PdfPopupIcon.Comment);
popup.setColor(new PdfRGBColor(Color.YELLOW));
page.getAnnotations().add(popup);

setLocation sets the annotation icon position, setText defines the tooltip content, and the annotation is added to the page’s collection.

4. Replacing Content

4.1 Replacing Text

To replace all occurrences of a specific word (case‑insensitive, for instance):

PdfTextReplaceOptions options = new PdfTextReplaceOptions();
options.setReplaceType(EnumSet.of(ReplaceActionType.IgnoreCase));

for (int i = 0; i < doc.getPages().getCount(); i++) {
    PdfPageBase page = doc.getPages().get(i);
    PdfTextReplacer replacer = new PdfTextReplacer(page);
    replacer.setOptions(options);
    replacer.replaceAllText("Water", "H₂O");
}

PdfTextReplacer processes each page. Note that this only works for real text content, not images or scanned pages.

4.2 Replacing an Image

When you need to update an image (e.g., a logo) in the PDF:

PdfImageHelper helper = new PdfImageHelper();
PdfImageInfo[] imageInfos = helper.getImagesInfo(page); // get all images on the page
PdfImage newImage = PdfImage.fromFile("C:\\work\\new_logo.png");
helper.replaceImage(imageInfos[0], newImage); // replace the first image

getImagesInfo returns an array of image metadata; replaceImage swaps the old image with the new one. You can loop through the array to replace a specific image based on position or other criteria.

5. Removing Content

5.1 Removing a Page

doc.getPages().removeAt(0); // deletes the first page

removeAt takes the zero‑based index of the page to remove.

5.2 Removing an Image

helper.deleteImage(imageInfos[0]);

Using the same PdfImageHelper, you can delete a specific image.

5.3 Removing an Annotation

page.getAnnotationsWidget().removeAt(0);

getAnnotationsWidget returns the annotation collection; removeAt deletes the annotation at the given index.

5.4 Removing an Attachment

If the document contains embedded attachments (e.g., another PDF or Excel file):

PdfAttachmentCollection attachments = doc.getAttachments();
if (attachments.size() > 0) {
    attachments.removeAt(0);
}

Always check the size before removing to avoid index errors.

6. Security Protection

6.1 Adding a Watermark

Watermarks are often used for branding or confidentiality. The code below draws a semi‑transparent “CONFIDENTIAL” text centered on every page:

PdfTrueTypeFont font = new PdfTrueTypeFont(new Font("Arial Black", Font.PLAIN, 50), true);
String watermark = "CONFIDENTIAL";
float opacity = 0.3f;

for (int i = 0; i < doc.getPages().getCount(); i++) {
    PdfPageBase page = doc.getPages().get(i);
    page.getCanvas().setTransparency(opacity);
    Dimension2D textSize = font.measureString(watermark);
    double x = (page.getActualSize().getWidth() - textSize.getWidth()) / 2;
    double y = (page.getActualSize().getHeight() - textSize.getHeight()) / 2;
    page.getCanvas().drawString(watermark, font, PdfBrushes.getGray(), x, y);
}

setTransparency controls the opacity, and measureString helps centre the text both horizontally and vertically.

6.2 Encrypting with a Password

To protect sensitive documents, use AES‑256 encryption and set permissions:

String userPassword = "user123";
String ownerPassword = "admin456";

PdfPasswordSecurityPolicy policy = new PdfPasswordSecurityPolicy(userPassword, ownerPassword);
policy.setEncryptionAlgorithm(PdfEncryptionAlgorithm.AES_256);
policy.setDocumentPrivilege(PdfDocumentPrivilege.getAllowAll());
policy.getDocumentPrivilege().setAllowModifyContents(false);
policy.getDocumentPrivilege().setAllowContentCopying(false);

doc.encrypt(policy);

userPassword is required to open the document, while ownerPassword controls permissions (e.g., printing, editing, copying). The setDocumentPrivilege method lets you fine‑tune what users are allowed to do.

7. Saving and Releasing Resources

After all modifications, save the document to a new file and close it:

doc.saveToFile("C:\\work\\output.pdf");
doc.close();

It is recommended to save under a different name to preserve the original file.

Final Thoughts

These code snippets cover the core PDF editing tasks I frequently encounter—inserting content, replacing text and images, removing elements, and applying security measures. One thing to keep in mind: text replacement works reliably only for selectable text, not scanned images, so always verify the source PDF type before processing. Also, remember to handle file paths carefully to avoid encoding issues. With these basics, you should be able to build more complex PDF workflows without reinventing the wheel.

Resize PDF Pages in C#: Change PDF Page Size

Leon Davis — Fri, 03 Jul 2026 12:09:29 +0000

PDF page size is often overlooked until a document needs to be printed, archived, or processed in bulk. In many business systems, PDF files may come from different sources: scanned documents, exported reports, generated invoices, or legacy templates. As a result, the page dimensions may not be consistent.

In a .NET application, one practical way to resize PDF pages is to create a new PDF document with the desired page size, then draw each original page onto the new page as a template. This keeps the visual content of the source PDF, including text, images, tables, and layout, while producing a document with standardized page dimensions.

This article demonstrates how to resize PDF pages in C# for two common scenarios:

Changing PDF pages to a standard paper size such as A4, A3, A1, Letter, or Legal
Changing PDF pages to a custom size defined in inches or millimeters

The examples use C# and Spire.PDF for .NET.

Install the PDF Library

Install the package from NuGet:

PM> Install-Package Spire.PDF

Or use the .NET CLI:

dotnet add package Spire.PDF

Then add the required namespaces:

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

How PDF Page Resizing Works

A PDF page has a fixed coordinate system. Unlike a Word document or an HTML page, its content does not automatically reflow when the page size changes.

For this reason, resizing a PDF page usually requires a different approach:

Load the original PDF document.
Create a new PDF document.
Add a new page with the target page size.
Convert the original page into a template.
Draw the template onto the new page.
Save the resized PDF file.

The key operation is creating a template from the original page:

PdfTemplate template = sourcePage.CreateTemplate();
template.Draw(newPage, new PointF(0, 0), layout);

This approach preserves the page appearance and scales the original page content into the new page area.

Resize PDF Pages to a Standard Paper Size in C

If the target size is a common paper format, you can use predefined values from PdfPageSize, such as A4, A3, A1, Letter, or Legal.

The following example resizes every page in a PDF document to A1 size.

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

namespace ResizePdfToStandardSize
{
    class Program
    {
        static void Main(string[] args)
        {
            PdfDocument sourcePdf = new PdfDocument();
            sourcePdf.LoadFromFile("Sample.pdf");

            PdfDocument outputPdf = new PdfDocument();

            foreach (PdfPageBase sourcePage in sourcePdf.Pages)
            {
                PdfPageBase newPage = outputPdf.Pages.Add(
                    PdfPageSize.A1,
                    new PdfMargins(0)
                );

                PdfTextLayout layout = new PdfTextLayout();
                layout.Layout = PdfLayoutType.OnePage;

                PdfTemplate template = sourcePage.CreateTemplate();
                template.Draw(newPage, new PointF(0, 0), layout);
            }

            outputPdf.SaveToFile("ResizeToA1.pdf");

            sourcePdf.Close();
            outputPdf.Close();
        }
    }
}

To resize the PDF to A4 instead, replace PdfPageSize.A1 with PdfPageSize.A4:

PdfPageBase newPage = outputPdf.Pages.Add(
    PdfPageSize.A4,
    new PdfMargins(0)
);

Other standard page sizes can be used in the same way:

PdfPageSize.A3
PdfPageSize.A4
PdfPageSize.Letter
PdfPageSize.Legal

The second argument controls the page margins:

new PdfMargins(0)

A margin value of 0 allows the original page template to use the full target page area. If you need additional whitespace around the content, you can set a larger margin value:

new PdfMargins(20)

Keep in mind that margins reduce the available drawing area, so the rendered page content may appear smaller.

Why `PdfLayoutType.OnePage` Is Important

The following setting is important when drawing the original page onto the resized page:

PdfTextLayout layout = new PdfTextLayout();
layout.Layout = PdfLayoutType.OnePage;

PdfLayoutType.OnePage helps fit the source page content into a single target page. Without this setting, the content may not scale as expected, especially when the original page size and the target page size are significantly different.

This is especially relevant when:

Resizing large pages to A4 or Letter
Enlarging small pages to A3 or A1
Processing scanned PDF pages
Normalizing PDFs with inconsistent page dimensions

It does not redesign the PDF layout, but it helps preserve the original page as a scaled visual representation.

Resize PDF Pages to a Custom Size in C

In some cases, a standard paper size is not suitable. For example, you may need to generate PDFs for labels, tickets, certificates, forms, or a specific print template.

Spire.PDF uses points as the measurement unit for page dimensions. One inch equals 72 points. Instead of calculating the values manually, you can use PdfUnitConvertor to convert inches, millimeters, or other units to points.

The following example resizes all pages to 6.5 × 8.5 inches.

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

namespace ResizePdfToCustomSize
{
    class Program
    {
        static void Main(string[] args)
        {
            PdfDocument sourcePdf = new PdfDocument();
            sourcePdf.LoadFromFile("Sample.pdf");

            PdfDocument outputPdf = new PdfDocument();

            PdfUnitConvertor convertor = new PdfUnitConvertor();

            float width = convertor.ConvertUnits(
                6.5f,
                PdfGraphicsUnit.Inch,
                PdfGraphicsUnit.Point
            );

            float height = convertor.ConvertUnits(
                8.5f,
                PdfGraphicsUnit.Inch,
                PdfGraphicsUnit.Point
            );

            SizeF customPageSize = new SizeF(width, height);

            foreach (PdfPageBase sourcePage in sourcePdf.Pages)
            {
                PdfPageBase newPage = outputPdf.Pages.Add(
                    customPageSize,
                    new PdfMargins(0)
                );

                PdfTextLayout layout = new PdfTextLayout();
                layout.Layout = PdfLayoutType.OnePage;

                PdfTemplate template = sourcePage.CreateTemplate();
                template.Draw(newPage, new PointF(0, 0), layout);
            }

            outputPdf.SaveToFile("ResizeToCustomSize.pdf");

            sourcePdf.Close();
            outputPdf.Close();
        }
    }
}

The custom page size is created with SizeF:

SizeF customPageSize = new SizeF(width, height);

Then the custom size is used when adding pages to the output PDF:

PdfPageBase newPage = outputPdf.Pages.Add(
    customPageSize,
    new PdfMargins(0)
);

This method is useful when the target PDF page size comes from a business requirement rather than a standard paper format.

Convert Millimeters to PDF Page Size

Print specifications are often written in millimeters. For example, an A4-sized page is commonly represented as 210mm × 297mm.

You can convert millimeters to points like this:

PdfUnitConvertor convertor = new PdfUnitConvertor();

float width = convertor.ConvertUnits(
    210f,
    PdfGraphicsUnit.Millimeter,
    PdfGraphicsUnit.Point
);

float height = convertor.ConvertUnits(
    297f,
    PdfGraphicsUnit.Millimeter,
    PdfGraphicsUnit.Point
);

SizeF pageSize = new SizeF(width, height);

Then use the converted pageSize when creating the new page:

PdfPageBase newPage = outputPdf.Pages.Add(
    pageSize,
    new PdfMargins(0)
);

Using PdfUnitConvertor keeps the code readable and avoids hardcoded point values that may be difficult to understand later.

Practical Considerations

Check the Aspect Ratio

If the original page and the target page use different aspect ratios, the resized PDF may contain extra whitespace or slightly compressed content. For example, converting a landscape page to portrait A4 can preserve the page content, but the visual result may not be ideal.

Review Scanned PDFs Carefully

Scanned PDFs often include hidden margins, uneven borders, or slightly rotated images. Resizing the page will also preserve these visual details, so the output should be checked manually if the source file comes from scans.

Avoid Overwriting the Original PDF

It is better to save the resized file as a new PDF instead of replacing the original one directly. This makes it easier to compare the output and roll back if the result is not correct.

Be Careful with Mixed Page Sizes

Some PDFs contain pages with different sizes by design. The examples above resize every page to the same target size, which is useful for printing and archiving, but it may not be suitable for every document.

Conclusion

Resizing PDF pages in C# is not just about changing a page property. A more reliable approach is to create a new PDF with the target page size and draw each original page onto the new page as a template.

For standard paper sizes such as A4, A3, Letter, or Legal, predefined page sizes can be used directly. For custom dimensions, the width and height can be converted from inches or millimeters to points before creating the new page.

This method works well when the goal is to preserve the original visual layout while standardizing page dimensions. After generating the resized PDF, it is still worth reviewing a few pages manually, especially when the source file contains scanned pages, mixed page sizes, or unusual aspect ratios.

Convert Word DOCX to Markdown in Java: Basic Conversion and Export Options

Leon Davis — Fri, 03 Jul 2026 11:30:21 +0000

Markdown is widely used in developer documentation, README files, static sites, internal knowledge bases, and Git-based content workflows. However, source documents are not always written in Markdown from the beginning. In many teams, product specs, technical drafts, reports, or user manuals may still arrive as Word documents.

This guide shows how to convert a Word document to Markdown in Java. We will start with the simplest DOCX-to-MD conversion, then add export options for images, lists, hyperlinks, underline formatting, tables, and Office Math equations.

The goal is not just to generate a .md file, but to understand which export settings matter when the Word document contains real-world formatting.

Prerequisites

Before starting, make sure you have:

JDK 8 or later
A Maven-based Java project
A DOCX file to test with
Basic familiarity with Java file paths

For the conversion API, this example uses Spire.Doc for Java. Add the Maven repository and dependency to your pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.doc</artifactId>
        <version>14.7.0</version>
    </dependency>
</dependencies>

The version above is used as an example. In a real project, check the latest available version before publishing or deploying your application.

Part 1: Basic Word to Markdown Conversion

If your Word document is simple, the conversion only needs three steps:

Create a Document object
Load the Word file
Save it as Markdown

Example Code

import com.spire.doc.*;

public class WordToMarkdownBasic {
    public static void main(String[] args) {
        Document document = new Document();

        try {
            document.loadFromFile("Data/toMarkdown.docx");
            document.saveToFile("toMarkdown_out.md", FileFormat.Markdown);
        } finally {
            document.close();
            document.dispose();
        }
    }
}

How It Works

The Document object represents the Word file in memory.

Document document = new Document();

Then the DOCX file is loaded from disk:

document.loadFromFile("Data/toMarkdown.docx");

Finally, the document is saved in Markdown format:

document.saveToFile("toMarkdown_out.md", FileFormat.Markdown);

This is enough for many plain documents, such as simple notes, short articles, or internal drafts.

However, Word files often contain more than plain text. Images, numbered lists, hyperlinks, tables, underlined text, and equations may need additional handling. That is where Markdown export options become useful.

Part 2: Convert Word to Markdown with Export Options

The following example shows how to configure Markdown output more precisely.

It includes options for:

Saving images to a local folder
Using Base64 images if needed
Controlling list output
Preserving underline formatting
Exporting hyperlinks as reference-style links
Exporting Office Math as MathML
Saving tables as HTML inside Markdown

Full Example Code

import com.spire.doc.*;

public class WordToMarkdownWithOptions {
    public static void main(String[] args) {
        Document document = new Document();

        try {
            // Load the source Word document.
            document.loadFromFile("Data/toMarkdown.docx");

            // Option 1: Embed images as Base64 strings in the Markdown file.
            // This keeps everything in one file, but the Markdown file may become large.
            // document.getMarkdownExportOptions().setImagesAsBase64(true);

            // Option 2: Save extracted images to a local folder.
            // The generated Markdown file will reference images from this folder.
            document.getMarkdownExportOptions().setImagesFolder("D:\\Markdown\\Images");

            // Set an alias path for the image folder in the generated Markdown.
            // This is useful if the image folder path in your local machine
            // is different from the path used after publishing.
            // document.getMarkdownExportOptions().setImagesFolderAlias("Images");

            // Output bullet and numbered lists as plain text.
            document.getMarkdownExportOptions().setListOutputMode(MarkdownListOutputMode.Plain_Text);

            // Preserve underline formatting where possible.
            document.getMarkdownExportOptions().setSaveUnderlineFormatting(true);

            // Export hyperlinks as reference-style Markdown links.
            document.getMarkdownExportOptions().setLinkOutputMode(MarkdownLinkOutputMode.Reference);

            // Export Office Math equations as MathML.
            document.getMarkdownExportOptions().setOfficeMathOutputMode(MarkdownOfficeMathOutputMode.Math_ML);

            // Save tables as HTML inside the Markdown file.
            // This is often safer for complex Word tables.
            document.getMarkdownExportOptions().setSaveAsHtml(MarkdownSaveAsHtml.Tables);

            // Save the document as Markdown.
            document.saveToFile("toMarkdown_out.md", FileFormat.Markdown);
        } finally {
            document.close();
            document.dispose();
        }
    }
}

Understanding the Export Options

1. Export Images as Separate Files

Word documents often contain screenshots, diagrams, logos, or inline images. When converting to Markdown, you need to decide how those images should be stored.

This option saves extracted images to a local folder:

document.getMarkdownExportOptions().setImagesFolder("D:\\Markdown\\Images");

This is usually the better choice for documentation projects because the Markdown file stays readable and lightweight.

A typical output may look like this:

![image](Images/image1.png)

This approach is useful when:

You publish Markdown to a documentation site
You store Markdown in Git
You want to manage images separately
You need to replace or optimize images later

2. Embed Images as Base64

You can also embed images directly into the Markdown file:

document.getMarkdownExportOptions().setImagesAsBase64(true);

This keeps the Markdown file self-contained, but it also makes the file much larger.

Base64 images may be useful for:

Small one-off documents
Temporary file transfer
Cases where external image files are inconvenient

For long-term documentation, separate image files are usually easier to maintain.

3. Use an Image Folder Alias

The image folder on your local machine may not be the same as the path used after publishing.

For example, locally you may save images here:

document.getMarkdownExportOptions().setImagesFolder("D:\\Markdown\\Images");

But in the final Markdown file, you may want image references to use a cleaner relative path:

document.getMarkdownExportOptions().setImagesFolderAlias("Images");

This is helpful when the Markdown file will be uploaded to a blog, Git repository, or static site generator.

4. Control List Output

Word lists and Markdown lists do not always map perfectly. Numbered lists, nested lists, and custom bullet styles can sometimes produce unexpected formatting.

This option exports lists as plain text:

document.getMarkdownExportOptions().setListOutputMode(MarkdownListOutputMode.Plain_Text);

This can be useful when the original order and wording matter more than Markdown list syntax.

For example, it may be suitable for:

Policy documents
Legal-style clauses
Exam papers
Structured internal documents

If you want the output to behave like normal Markdown, test the result before deciding whether Plain_Text is the best choice.

5. Preserve Underline Formatting

Markdown does not have a standard underline syntax. Some Markdown processors support underline through HTML, while others do not.

If the source Word document uses underline formatting for important content, enable:

document.getMarkdownExportOptions().setSaveUnderlineFormatting(true);

This is especially useful for:

Fill-in-the-blank exercises
Forms
Emphasized terms
Documents where underline has semantic meaning

If underline is only decorative, you may not need this option.

6. Export Links as Reference-Style Markdown

Markdown supports different hyperlink styles. This example uses reference-style links:

document.getMarkdownExportOptions().setLinkOutputMode(MarkdownLinkOutputMode.Reference);

A reference-style link looks like this:

Read the [documentation][1].

[1]: https://example.com

This keeps the main text cleaner, especially when the document contains many links.

Reference-style links are a good fit for:

Technical documentation
Research notes
Long-form tutorials
API guides

For short documents, inline links may be easier to read.

7. Export Office Math as MathML

If your Word document contains equations created with Office Math, you can export them as MathML:

document.getMarkdownExportOptions().setOfficeMathOutputMode(MarkdownOfficeMathOutputMode.Math_ML);

This can preserve mathematical structure better than plain text.

However, MathML support depends on where the Markdown will be rendered. Some platforms display MathML well, while others may show raw markup or require additional rendering support.

Before using this in production, test a few documents that contain real equations.

8. Save Tables as HTML

Markdown tables are simple and readable, but they have limitations. Word tables can be much more complex. They may contain:

Merged cells
Nested content
Multiple paragraphs in one cell
Special borders
Complex alignment

For these cases, saving tables as HTML inside the Markdown file can produce a more stable result:

document.getMarkdownExportOptions().setSaveAsHtml(MarkdownSaveAsHtml.Tables);

This makes the Markdown file less minimal, but it can preserve complex tables more accurately.

Use this option when table structure is more important than Markdown purity.

Common Issues and Fixes

Images Do Not Appear in the Markdown Preview

Check the following:

Were the images exported to the expected folder?
Does the Markdown file reference the correct relative path?
Is the Markdown file being previewed from the correct directory?
Did you move the .md file without moving the image folder?

A common fix is to keep the Markdown file and image folder together:

output
├── article.md
└── Images
    ├── image1.png
    └── image2.png

The Markdown File Is Too Large

If you enabled Base64 images, the output file can become large quickly.

Instead of:

document.getMarkdownExportOptions().setImagesAsBase64(true);

Use:

document.getMarkdownExportOptions().setImagesFolder("output/Images");

This keeps the Markdown file easier to edit and review.

Tables Look Broken

If the source document contains complex Word tables, regular Markdown tables may not be enough.

Use HTML table output:

document.getMarkdownExportOptions().setSaveAsHtml(MarkdownSaveAsHtml.Tables);

This is often a better trade-off for documents where table structure must be preserved.

Equations Are Not Rendering Correctly

MathML output depends on the target renderer.

If equations do not display correctly, consider:

Testing another Markdown preview tool
Checking whether the publishing platform supports MathML
Converting equations to images for platforms with limited formula support
Using a platform-specific math format if available

Lists Do Not Match the Original Word Document

Word lists can include custom numbering, indentation, and nested styles. If Markdown list output looks inconsistent, try plain-text list output:

document.getMarkdownExportOptions().setListOutputMode(MarkdownListOutputMode.Plain_Text);

This may preserve the reading order more reliably, although the result may not behave like a normal Markdown list.

Final Thoughts

The basic Word-to-Markdown conversion is straightforward, but real documents usually require a few export decisions.

If your Word documents are simple, start with the basic converter. If they contain images, tables, links, or equations, enable only the options you actually need and test the output in your target Markdown platform before using it in production.

How to Split a PowerPoint Document into Multiple Files in Java

Leon Davis — Fri, 26 Jun 2026 10:38:03 +0000

When working with PowerPoint files in a Java application, you may sometimes need to split a large presentation into smaller files.

For example, you might have a training deck that contains several chapters and want to save each chapter as a separate presentation. Or you may need to export every slide as an individual PPTX file so the slides can be reviewed, archived, or reused separately.

Doing this manually in PowerPoint is fine for a few slides, but it quickly becomes tedious when the file contains dozens or hundreds of slides. A better approach is to handle the process programmatically: load the original PowerPoint file, copy the required slides, and save them as new PPTX documents.

This article shows two common ways to split a PowerPoint document in Java:

Split a presentation into one file per slide.
Split a presentation by a specified slide range.

Install the PowerPoint Processing Library

Java does not provide a built-in API for editing PowerPoint files, so this example uses Spire.Presentation for Java to load, copy, and save PPTX documents.

If you are using Maven, add the following repository and dependency to your pom.xml file:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.presentation</artifactId>
        <version>11.5.1</version>
    </dependency>
</dependencies>

After the dependency is added, you can use the Presentation class to read and manipulate PowerPoint files.

Split a PowerPoint File into One File per Slide

The first case is to split a presentation so that each slide becomes a separate PPTX file.

The basic idea is simple:

Load the source PowerPoint file.
Loop through all slides in the presentation.
Create a new PowerPoint document for each slide.
Remove the default blank slide from the new document.
Append the current slide from the source file.
Save the new document as a separate PPTX file.

Here is the complete Java example:

import com.spire.presentation.FileFormat;
import com.spire.presentation.Presentation;

public class SplitPptBySingleSlide {
    public static void main(String[] args) throws Exception {
        // Load the source PowerPoint file
        Presentation sourcePpt = new Presentation();
        sourcePpt.loadFromFile("test1.pptx");

        // Get the total number of slides
        int slideCount = sourcePpt.getSlides().getCount();

        // Split each slide into a separate presentation
        for (int i = 0; i < slideCount; i++) {
            // Create a new PowerPoint document
            Presentation resultPpt = new Presentation();

            // Remove the default blank slide
            resultPpt.getSlides().removeAt(0);

            // Add the current slide to the new document
            resultPpt.getSlides().append(sourcePpt.getSlides().get(i));

            // Save the new presentation
            String outputFile = String.format("Split_Result_Slide_%d.pptx", i + 1);
            resultPpt.saveToFile(outputFile, FileFormat.PPTX_2013);
        }
    }
}

After running the code, the output files will look like this:

Split_Result_Slide_1.pptx
Split_Result_Slide_2.pptx
Split_Result_Slide_3.pptx
...

One thing to keep in mind is that slide indexes start from 0 in the API. So the first slide is accessed by get(0), the second slide by get(1), and so on.

Split a PowerPoint File by Slide Range

In many real-world cases, you may not want to split every slide into an individual file. Instead, you may want to split the presentation by sections or chapters.

For example:

Save slides 1-2 as Part1.pptx.
Save slides 3-4 as Part2.pptx.

The following example shows how to do that:

import com.spire.presentation.FileFormat;
import com.spire.presentation.Presentation;

public class SplitPptByRange {
    public static void main(String[] args) throws Exception {
        // Load the source PowerPoint file
        Presentation sourcePpt = new Presentation();
        sourcePpt.loadFromFile("test1.pptx");

        // Save slides 1-2 as a new presentation
        Presentation partOne = new Presentation();
        partOne.getSlides().removeAt(0);

        for (int i = 0; i < 2; i++) {
            partOne.getSlides().append(sourcePpt.getSlides().get(i));
        }

        partOne.saveToFile("Part1.pptx", FileFormat.PPTX_2013);

        // Save slides 3-4 as another presentation
        Presentation partTwo = new Presentation();
        partTwo.getSlides().removeAt(0);

        for (int i = 2; i < 4; i++) {
            partTwo.getSlides().append(sourcePpt.getSlides().get(i));
        }

        partTwo.saveToFile("Part2.pptx", FileFormat.PPTX_2013);
    }
}

The important part here is the slide index:

Slide 1 -> index 0
Slide 2 -> index 1
Slide 3 -> index 2
Slide 4 -> index 3

So if you want to extract slides 1 to 2, the loop should be:

for (int i = 0; i < 2; i++)

If you want to extract slides 3 to 4, the loop should be:

for (int i = 2; i < 4; i++)

Create a Reusable Method for Splitting Slides

If slide splitting is needed in multiple places in your project, it is better to wrap the logic in a reusable method.

The example below defines a splitByRange() method. You only need to pass the source presentation, start index, end index, and output file name.

import com.spire.presentation.FileFormat;
import com.spire.presentation.Presentation;

public class SplitPptUtil {
    public static void main(String[] args) throws Exception {
        Presentation sourcePpt = new Presentation();
        sourcePpt.loadFromFile("test1.pptx");

        // Extract slides 1-2
        splitByRange(sourcePpt, 0, 2, "Chapter_1.pptx");

        // Extract slides 3-4
        splitByRange(sourcePpt, 2, 4, "Chapter_2.pptx");

        // Extract slides 5-6
        splitByRange(sourcePpt, 4, 6, "Chapter_3.pptx");
    }

    /**
     * Split a PowerPoint file by slide range.
     *
     * @param sourcePpt  The source presentation.
     * @param startIndex The start slide index, inclusive.
     * @param endIndex   The end slide index, exclusive.
     * @param outputFile The output PPTX file name.
     */
    private static void splitByRange(Presentation sourcePpt, int startIndex, int endIndex, String outputFile) throws Exception {
        Presentation newPpt = new Presentation();
        newPpt.getSlides().removeAt(0);

        for (int i = startIndex; i < endIndex; i++) {
            newPpt.getSlides().append(sourcePpt.getSlides().get(i));
        }

        newPpt.saveToFile(outputFile, FileFormat.PPTX_2013);
    }
}

The method uses a common Java convention: the start index is inclusive, and the end index is exclusive.

For example:

splitByRange(sourcePpt, 0, 2, "Chapter_1.pptx");

This extracts slide indexes 0 and 1, which means slide 1 and slide 2 in the actual PowerPoint file.

Final Thoughts

Splitting a PowerPoint file in Java mainly involves three steps:

Load the original presentation.
Copy the required slides into a new presentation.
Save the new presentation as a separate PPTX file.

If each slide needs to be saved separately, you can simply loop through all slides. If the file should be split by chapter or slide range, you can control the process using slide indexes.

This approach is useful for training materials, reports, courseware, document management systems, and any workflow where PowerPoint files need to be processed in batches.

How to Change PDF Backgrounds in Java: Add Background Colors and Images

Leon Davis — Wed, 24 Jun 2026 08:58:49 +0000

When working with contracts, reports, notices, certificates, or other PDF files, the document layout often matters just as much as the content. For example, you may want to add a soft background color to a report, apply a company letterhead to a contract, or place a fixed template image behind an official document.

Doing this manually is fine for one or two files, but it quickly becomes inefficient when the files need to be processed in batches. A better approach is to handle the PDF background directly in Java code.

This article shows two common ways to change the background of a PDF file in Java: adding a background color and setting a background image.

1. Add the Java PDF Library

In this example, we will use Spire.PDF for Java to load an existing PDF document, update the background of its pages, and save the result as a new PDF file.

If your project uses Maven, add the Spire.PDF dependency to your pom.xml file:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.6.1</version>
    </dependency>
</dependencies>

You can adjust the version number based on your project requirements.

2. Add a Background Color to a PDF in Java

A PDF file does not usually have a single global background setting. Since each page may have a different size, orientation, or layout, it is common to apply the background page by page.

The following example sets a light blue background for every page in an existing PDF file. It also uses opacity to control how strong the background color appears.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;

import java.awt.Color;

public class AddPdfBackgroundColor {

    public static void main(String[] args) {
        String inputPath = "input.pdf";
        String outputPath = "output-background-color.pdf";

        PdfDocument document = new PdfDocument();

        // Load the source PDF file.
        document.loadFromFile(inputPath);

        // Loop through all pages in the PDF document.
        for (int pageIndex = 0; pageIndex < document.getPages().getCount(); pageIndex++) {
            PdfPageBase page = document.getPages().get(pageIndex);

            // Set a light blue background color for the current page.
            page.setBackgroundColor(new Color(230, 240, 255));

            // Set the background opacity. A larger value makes the color more visible.
            page.setBackgroudOpacity(0.35f);
        }

        // Save the modified PDF as a new file to avoid overwriting the original one.
        document.saveToFile(outputPath);

        // Release PDF resources.
        document.close();
    }
}

You can tune the opacity value depending on the visual effect you want:

// Use a very light background, suitable for text-heavy documents.
page.setBackgroudOpacity(0.15f);

// Use a stronger background effect, suitable for cover pages or section pages.
page.setBackgroudOpacity(0.5f);

For formal documents such as contracts, notices, or approval forms, it is usually better to keep the background subtle so that it does not affect readability or printing.

3. Add a Background Image to a PDF in Java

Besides a solid color, you can also use an image as the PDF background. This is useful for company letterheads, brand templates, certificate designs, watermark-style backgrounds, and other fixed layouts.

The following example reads an image file and applies it as the background of every page in the PDF.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class AddPdfBackgroundImage {

    public static void main(String[] args) throws IOException {
        String inputPath = "input.pdf";
        String imagePath = "background.jpg";
        String outputPath = "output-background-image.pdf";

        PdfDocument document = new PdfDocument();

        // Load the PDF file that needs a background image.
        document.loadFromFile(inputPath);

        // Read the image that will be used as the page background.
        BufferedImage backgroundImage = ImageIO.read(new File(imagePath));

        // Apply the same background image to each page in the PDF.
        for (int pageIndex = 0; pageIndex < document.getPages().getCount(); pageIndex++) {
            PdfPageBase page = document.getPages().get(pageIndex);

            // Set the image as the background of the current page.
            page.setBackgroundImage(backgroundImage);

            // Adjust the image opacity so the original PDF content remains readable.
            page.setBackgroudOpacity(0.25f);
        }

        // Save the result as a new PDF file.
        document.saveToFile(outputPath);

        // Close the document to release resources.
        document.close();
    }
}

If the background image is dark or visually complex, it is better to use a lower opacity. Otherwise, the background may interfere with the original text, tables, or stamps in the PDF.

For letterhead-style backgrounds or light texture images, an opacity value between 0.15f and 0.3f is often a good starting point. For certificates or cover pages, you can increase the value slightly, but it is still a good idea to export a sample file and check the final appearance.

4. Add a Background to Specific PDF Pages Only in Java

In real projects, not every page needs the same background. For example, you may only want to add a background image to the first page while keeping the rest of the document unchanged.

The following example applies a background color only to the first page:

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;

import java.awt.Color;

public class AddBackgroundToFirstPage {

    public static void main(String[] args) {
        PdfDocument document = new PdfDocument();

        // Load the original PDF document.
        document.loadFromFile("input.pdf");

        // Make sure the document has at least one page before accessing the first page.
        if (document.getPages().getCount() > 0) {
            PdfPageBase firstPage = document.getPages().get(0);

            // Apply a warm background color to the first page.
            firstPage.setBackgroundColor(new Color(245, 238, 220));

            // Set the opacity of the background color.
            firstPage.setBackgroudOpacity(0.4f);
        }

        // Save the updated PDF as a separate file.
        document.saveToFile("output-first-page-background.pdf");

        // Release PDF resources.
        document.close();
    }
}

If you need to process several specific pages, you can check the page number inside the loop. The following example only updates pages 1, 3, and 5:

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;

import java.awt.Color;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class AddBackgroundToSelectedPages {

    public static void main(String[] args) {
        PdfDocument document = new PdfDocument();

        // Load the source PDF file.
        document.loadFromFile("input.pdf");

        // Define the page numbers that need a background.
        // Page numbers here start from 1, which is easier to match with what users see in a PDF reader.
        Set<Integer> targetPages = new HashSet<>(Arrays.asList(1, 3, 5));

        // Loop through all pages and apply the background only to selected pages.
        for (int pageIndex = 0; pageIndex < document.getPages().getCount(); pageIndex++) {
            int pageNumber = pageIndex + 1;

            // Skip pages that are not included in the target page list.
            if (!targetPages.contains(pageNumber)) {
                continue;
            }

            PdfPageBase page = document.getPages().get(pageIndex);

            // Set a light green background for the selected page.
            page.setBackgroundColor(new Color(240, 248, 240));

            // Control how visible the background color should be.
            page.setBackgroudOpacity(0.3f);
        }

        // Save the processed PDF document.
        document.saveToFile("output-selected-pages-background.pdf");

        // Close the document after saving.
        document.close();
    }
}

This approach keeps the page numbers in the code consistent with the page numbers users normally see, which helps avoid off-by-one mistakes.

5. Practical Notes

1. Save the Result as a New File

It is safer not to overwrite the original PDF directly. Save the modified file to a new path first, review the output, and then decide whether to replace the original file.

// Save the processed PDF to a new file instead of overwriting the source file.
document.saveToFile("new-file.pdf");

This makes it easier to recover if the background color is too strong, the image does not look right, or the output needs further adjustment.

2. Avoid Oversized Background Images

If a high-resolution image is applied to every page, the output PDF may become much larger. For background textures, letterheads, or watermark-style images, extremely large images are usually unnecessary.

A good practice is to compress the image before using it in the PDF, especially when the document has many pages.

3. Adjust Opacity Based on the Content

A background should support the document layout, not compete with the main content. For text-heavy PDFs, use a lower opacity. For covers, certificates, or visual templates, a stronger background may be acceptable.

You can test several values first:

// Very light background effect.
page.setBackgroudOpacity(0.15f);

// Moderate background effect.
page.setBackgroudOpacity(0.25f);

// More visible background effect.
page.setBackgroudOpacity(0.35f);

Then choose the value that works best for the exported PDF.

4. Check the Structure of the Original PDF

Some PDF files are actually scanned documents, where each page is a full-page image. Others may already contain a white page-sized image or background block. In these cases, the newly added background may not be visually obvious.

If this happens, the code may still be working correctly. The issue is that the existing page content already covers most or all of the visible area. For scanned PDFs, you may need a different strategy, such as editing the scanned images themselves or regenerating the PDF from source data.

6. Conclusion

Changing a PDF background in Java is straightforward when the library provides page-level background APIs. For a simple color background, you can use setBackgroundColor(). For a template, letterhead, or design image, you can use setBackgroundImage().

In real-world use, the main things to watch are file safety, background opacity, and image size. Save the output as a new file first, keep the background light enough for reading, and avoid using unnecessarily large images.

For batch processing scenarios such as contracts, reports, electronic certificates, notices, and archived documents, this approach can be easily integrated into a Java backend service.

Java - Extract Images from PDF and Compress PDF Image Size

Leon Davis — Thu, 18 Jun 2026 12:22:31 +0000

In some document processing scenarios, PDF files often contain many images, such as scanned documents, product manuals, report attachments, contract images, and so on. Sometimes we need to extract images from a PDF for archiving, recognition, or further editing. In other cases, a PDF file may become too large because it contains high-resolution images, and image compression becomes necessary.

This article uses demonstrate two common operations:

Extract images from a PDF document in Java
Compress high-quality images in a PDF document in Java

1. Preparation

The sample code uses a Maven project. First, add the Spire.PDF for Java dependency to your pom.xml file.

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.6.1</version>
    </dependency>
</dependencies>

If you are using a regular Java project, you can also manually add the corresponding Jar file to your project dependencies. For demonstration purposes, the following code uses local file paths. You need to modify them according to your actual directory structure.

2. Extract Images from a PDF in Java

1. Implementation Logic

The core process of extracting images is straightforward:

Load the PDF file;
Traverse each page of the PDF;
Get the image information on the current page;
Save the image object as a local image file.

In Spire.PDF, you can use PdfImageHelper to get image information from a PDF page, then use PdfImageInfo.getImage() to obtain a BufferedImage object, and finally use ImageIO.write() to write it to a local file.

2. Sample Code

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.utilities.PdfImageHelper;
import com.spire.pdf.utilities.PdfImageInfo;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ExtractPdfImages {

    public static void main(String[] args) throws IOException {
        String inputPdf = "C:/pdf/input.pdf";
        String outputDir = "C:/pdf/images/";

        PdfDocument document = new PdfDocument();

        try {
            // Load the PDF file
            document.loadFromFile(inputPdf);

            // Create the output directory
            File dir = new File(outputDir);
            if (!dir.exists()) {
                dir.mkdirs();
            }

            PdfImageHelper imageHelper = new PdfImageHelper();
            int imageIndex = 1;

            // Traverse each page of the PDF
            for (int pageIndex = 0; pageIndex < document.getPages().getCount(); pageIndex++) {
                PdfPageBase page = document.getPages().get(pageIndex);

                // Get all images from the current page
                PdfImageInfo[] imageInfos = imageHelper.getImagesInfo(page);

                // Save images
                for (PdfImageInfo imageInfo : imageInfos) {
                    BufferedImage image = imageInfo.getImage();

                    String fileName = String.format(
                            "page-%d-image-%d.png",
                            pageIndex + 1,
                            imageIndex++
                    );

                    File outputFile = new File(outputDir + fileName);
                    ImageIO.write(image, "PNG", outputFile);
                }
            }

            System.out.println("Image extraction completed. Total images exported: " + (imageIndex - 1));

        } finally {
            document.dispose();
        }
    }
}

3. Code Explanation

Instead of using a simple name like image-1.png, the code includes the page number in the file name, for example:

page-1-image-1.png
page-2-image-3.png

This makes it easier to locate the source page of each extracted image later. Especially when a PDF has many pages, using only sequential numbers makes it harder to identify where each image originally came from.

In this example, the extracted images are saved in PNG format. If the images in the original PDF are already large, saving them as PNG may not reduce the file size. If the images are only used for preview or web display, you can save them as JPG instead.

For example:

ImageIO.write(image, "JPG", outputFile);

However, JPG is a lossy format and is more suitable for photos. It is not ideal for text screenshots, table screenshots, or images with transparent backgrounds.

3. Compress Images in a PDF in Java

1. Applicable Scenarios

When a PDF file is too large, images are often one of the main reasons. For example:

The resolution of scanned documents is too high;
A report contains many high-definition images;
Images are inserted directly into the PDF without compression;
The PDF has only a few pages, but the file size reaches dozens of MB.

In such cases, you can try compressing the images in the PDF to reduce the overall file size.

However, image compression may reduce image quality to some extent. If the PDF is used for printing, archiving, or formal delivery, it is recommended to back up the original file first and compress a copy instead.

2. Sample Code

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.utilities.PdfImageHelper;
import com.spire.pdf.utilities.PdfImageInfo;

import java.io.File;

public class CompressPdfImages {

    public static void main(String[] args) {
        String inputPdf = "C:/pdf/input.pdf";
        String outputPdf = "C:/pdf/output-compressed.pdf";

        PdfDocument document = new PdfDocument();

        try {
            // Load the PDF file
            document.loadFromFile(inputPdf);

            // Disable incremental update to avoid abnormal file size increase after saving
            document.getFileInfo().setIncrementalUpdate(false);

            PdfImageHelper imageHelper = new PdfImageHelper();

            // Traverse each page and compress images on the page
            for (int pageIndex = 0; pageIndex < document.getPages().getCount(); pageIndex++) {
                PdfPageBase page = document.getPages().get(pageIndex);

                PdfImageInfo[] imageInfos = imageHelper.getImagesInfo(page);

                for (PdfImageInfo imageInfo : imageInfos) {
                    imageInfo.tryCompressImage();
                }
            }

            // Save the compressed PDF
            document.saveToFile(outputPdf, FileFormat.PDF);

            printFileSize(inputPdf, outputPdf);

        } finally {
            document.dispose();
        }
    }

    private static void printFileSize(String beforePath, String afterPath) {
        File before = new File(beforePath);
        File after = new File(afterPath);

        double beforeMb = before.length() / 1024.0 / 1024.0;
        double afterMb = after.length() / 1024.0 / 1024.0;

        System.out.printf("Before compression: %.2f MB%n", beforeMb);
        System.out.printf("After compression: %.2f MB%n", afterMb);
    }
}

4. Explanation of `setIncrementalUpdate(false)`

When compressing a PDF, there is one line in the code:

document.getFileInfo().setIncrementalUpdate(false);

It is recommended to keep this step.

When a PDF is saved, it may use incremental update mode. This means that the modified content is appended to the end of the original file instead of rewriting the entire file. This approach is suitable for some editing scenarios, but when compressing images, it may cause old data to remain in the file. As a result, you may find that the images have been compressed, but the PDF file size has not decreased significantly.

Therefore, when compressing images in a PDF, disabling incremental update can make the saved result better match the expected compressed output.

5. Frequently Asked Questions

1. Why can’t some images be extracted from a PDF?

Not everything that looks like an image is necessarily an image object in a PDF.

For example:

The page content may be vector graphics;
Text and graphics may be generated by drawing instructions;
A scanned document may use one large image for the entire page;
Images in some PDFs may be specially encoded or packaged.

Therefore, in real projects, you should test with PDFs from different sources instead of judging compatibility based on only one sample file.

2. What if the PDF file size does not change much after compression?

There may be several reasons:

The main file size does not come from images, but from fonts, attachments, or other resources;
The images have already been compressed;
There are not many images in the PDF;
The original PDF has a special saving structure;
The compression ratio is limited, so the size change is not obvious.

It is recommended to compare the file size before and after compression and test with real business documents as much as possible.

3. Will compression affect image clarity?

It may.

The goal of image compression is to reduce file size, which usually affects image quality to some degree. If the PDF needs to be printed, stamped, or archived, it is better not to overwrite the original file. Instead, output a new compressed version.

6. Conclusion

This article demonstrates two common PDF image processing requirements in Java:

Use PdfImageHelper.getImagesInfo() to get image information from PDF pages;
Use PdfImageInfo.getImage() to extract images;
Use PdfImageInfo.tryCompressImage() to compress images in a PDF;
Disable incremental update when saving the PDF to avoid ineffective compression.

In real business scenarios, it is recommended to encapsulate “image extraction” and “PDF compression” as separate utility methods, and add file size checks, exception handling, directory validation, and other logic. This makes the code easier to reuse for document archiving, attachment processing, or batch PDF compression.

Print Word Document in Java

Leon Davis — Thu, 18 Jun 2026 11:49:54 +0000

In enterprise applications, Word document printing is usually not a core feature at first glance, but it often becomes essential once workflows move into production.

Common scenarios include:

Automated generation and printing of reports
Batch printing of contracts, invoices, or statements
Backend services generating documents without user interaction
Integration with enterprise systems such as ERP or OA platforms

Unlike plain text printing, Word document printing involves rendering layout, maintaining formatting consistency, and interacting with system-level printers. These details are where most implementation challenges appear in real projects.

This guide walks through practical ways to print Word documents in Java, from basic usage to more controlled scenarios like page setup, duplex printing, and batch processing.

Environment setup

For handling Word documents, Spire.Doc is used here as the document processing layer. It takes care of loading and rendering Word files before they are sent to the printer.

Maven dependency:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.doc</artifactId>
        <version>14.6.0</version>
    </dependency>
</dependencies>

1. Simple Way to Print Word Document in Java

The most direct approach is to load the document and send it to the printer.

Document document = new Document();
document.loadFromFile("data/report.docx");

document.getPrintDocument().print();

document.dispose();

This approach relies entirely on default system behavior.

In practice, it:

Uses the default system printer
Keeps original document formatting
Requires no layout or printer configuration

It works well when printing requirements are minimal and consistency across printers is not a concern.

2. Java Word Printing with PrinterJob for Layout Control

Once printing requirements become more strict, default behavior is usually not enough.

Typical needs include controlling margins, adjusting layout behavior, or setting multiple copies.

Java’s PrinterJob API provides that level of control.

Document document = new Document();
document.loadFromFile("data/report.docx");

PrinterJob printerJob = PrinterJob.getPrinterJob();

PageFormat pageFormat = printerJob.defaultPage();
Paper paper = pageFormat.getPaper();

// Override default margins to use full page
paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());

// Print multiple copies
printerJob.setCopies(2);

pageFormat.setPaper(paper);

printerJob.setPrintable(document, pageFormat);
printerJob.print();

document.dispose();

This approach is typically used when:

Print layout must be consistent across environments
Margins and printable area need explicit control
Multiple copies are required in a single job

3. Custom Paper Size Configuration for Word Printing

In real business systems, documents are not always standard A4 pages. Labels, receipts, and custom reports often require different page sizes.

Document doc = new Document();
doc.loadFromFile("data/report.docx");

PrintDocument printDoc = doc.getPrintDocument();

PaperSize paperSize = new PaperSize();
paperSize.setWidth(900);
paperSize.setHeight(800);

printDoc.getDefaultPageSettings().setPaperSize(paperSize);

printDoc.print();

doc.dispose();

Paper sizes in Java printing are defined in points:

Paper Type	Size (points)
A4	595 × 842
Letter	612 × 792
Legal	612 × 1008
A3	842 × 1191

1 inch equals 72 points

Incorrect paper configuration is one of the most common reasons for layout issues when printing Word documents programmatically.

4. Page Margins and Duplex Printing in Java

In production document systems, margin control and duplex printing are often required for consistency and cost efficiency.

Document doc = new Document();
doc.loadFromFile("data/report.docx");

PrintDocument printDoc = doc.getPrintDocument();

printDoc.setOriginAtMargins(true);

// Set page margins (left, top, right, bottom)
printDoc.getDefaultPageSettings()
        .setMargins(new Margins(0, 0, 0, 0));

// Enable duplex printing (long-edge binding)
printDoc.getPrinterSettings().setDuplex(Duplex.Vertical);

printDoc.print();

doc.dispose();

Duplex printing modes

Mode	Description	Typical use case
Duplex.Vertical	Long-edge binding	Reports, books
Duplex.Horizontal	Short-edge binding	Calendars
Simplex	Single-sided printing	Default output

In practice, duplex behavior may also depend on printer drivers and hardware support, not just application-level configuration.

5. Batch Printing Multiple Word Documents in Java

Batch printing is common in automated document systems, where files are processed from a directory rather than individually triggered.

File folder = new File("C:\\Documents\\ToPrint");

File[] files = folder.listFiles((dir, name) ->
        name.toLowerCase().endsWith(".docx") ||
        name.toLowerCase().endsWith(".doc")
);

for (File file : files) {

    Document document = null;

    try {
        document = new Document();
        document.loadFromFile(file.getAbsolutePath());

        PrintDocument printDoc = document.getPrintDocument();
        printDoc.print();

        System.out.println("Printed: " + file.getName());

    } catch (Exception e) {
        System.err.println("Failed: " + file.getName());

    } finally {
        if (document != null) {
            document.dispose();
        }
    }
}

In batch scenarios, stability matters more than performance optimization:

Each document must be isolated
Failures should not interrupt the entire batch
Memory should be released consistently after each print job

6. Common Issues When Printing Word Documents in Java

Print dialog appears during execution

This usually happens when the printing process is not fully configured for silent execution or the system defaults override programmatic settings.

Document layout is cut off or misaligned

This is typically caused by:

Incorrect paper size configuration
Improper margin setup
Printer scaling or driver behavior

Duplex printing does not work as expected

In most cases, this is not a code issue but a limitation of the printer or its driver settings.

If duplex is not supported, the system will fall back to single-sided printing.

printDoc.getPrinterSettings().setDuplex(Duplex.Simplex);

7. Practical Considerations for Production Printing Systems

Always release document resources

try {
    document.loadFromFile(filePath);
} finally {
    document.dispose();
}

Resource cleanup is critical in batch processing environments.

Validate environment before printing

Before sending a print job, it is usually necessary to ensure:

The file exists and is accessible
A valid printer is available
Paper size and layout are correctly defined

Conclusion

Printing Word documents in Java is straightforward at the API level, but real-world implementation depends heavily on printer environments, driver behavior, and document formatting consistency.

Most production issues are not caused by code itself, but by differences between printers and system configurations.