DEV Community: Leon Davis

How to Add, Read, and Remove Speaker Notes in PowerPoint Using Java

Leon Davis — Fri, 14 Aug 2026 11:30:18 +0000

Speaker notes are useful when the content shown on a PowerPoint slide is not enough for the presenter. They can contain talking points, explanations, reminders, references, or instructions that should not appear directly on the slide.

For presentations created or maintained by an application, these notes may also need to be generated automatically. For example, a training system can build slides from a template and insert instructor notes at the same time, while a document-processing workflow may need to extract existing notes for review, archiving, or migration.

This article shows how to use Java to add speaker notes to PowerPoint slides, read existing notes, remove them when they are no longer needed, and process notes across multiple slides.

Install the Java PowerPoint Library

This example uses Spire.Presentation for Java. If you use Maven, add the 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.presentation</artifactId>
        <version>11.7.2</version>
    </dependency>
</dependencies>

You can also download the JAR package and add the required files to the project manually if Maven is not used.

Add Speaker Notes to a PowerPoint Slide

In PowerPoint, speaker notes are associated with individual slides. A slide can therefore have its own notes content without displaying that text during the normal slide show.

With Spire.Presentation for Java, you can access a slide through the presentation's slide collection, create its notes slide, and then append one or more paragraphs to the notes text frame.

The following example adds several speaker notes to the first slide:

import com.spire.presentation.*;

public class AddSpeakerNotes {

    public static void main(String[] args) throws Exception {

        // Load the PowerPoint presentation
        Presentation presentation = new Presentation();
        presentation.loadFromFile("input.pptx");

        // Get the first slide
        ISlide slide = presentation.getSlides().get(0);

        // Create a notes slide for the selected slide
        NotesSlide notesSlide = slide.addNotesSlide();

        // Add the first note paragraph
        ParagraphEx paragraph = new ParagraphEx();
        paragraph.setText("Key message:");
        notesSlide.getNotesTextFrame().getParagraphs().append(paragraph);

        // Add another note paragraph
        paragraph = new ParagraphEx();
        paragraph.setText(
                "Explain that the increase was mainly driven by enterprise customers."
        );
        notesSlide.getNotesTextFrame().getParagraphs().append(paragraph);

        // Add another note paragraph
        paragraph = new ParagraphEx();
        paragraph.setText(
                "Mention the regional breakdown before moving to the next slide."
        );
        notesSlide.getNotesTextFrame().getParagraphs().append(paragraph);

        // Save the result
        presentation.saveToFile(
                "PresentationWithNotes.pptx",
                FileFormat.PPTX_2013
        );

        presentation.dispose();
    }
}

The key step is creating a notes slide for the target slide:

NotesSlide notesSlide = slide.addNotesSlide();

Once the notes slide is available, its text frame can contain one or more paragraphs.

For example:

ParagraphEx paragraph = new ParagraphEx();
paragraph.setText("Key message:");

notesSlide.getNotesTextFrame()
        .getParagraphs()
        .append(paragraph);

Using separate paragraphs is useful when the notes contain several distinct talking points rather than one long block of text. It also makes the notes easier to update or remove individually later.

This approach works well for presentations generated from structured data. A reporting system, for example, might create a chart on the slide while storing the explanation of the chart in the corresponding notes section.

Read Speaker Notes from PowerPoint

Speaker notes are not always created by your own application. You may need to inspect a presentation uploaded by a user, collect presenter instructions from an existing slide deck, or export notes into another format.

To read the notes associated with a slide, first obtain its NotesSlide object:

NotesSlide notesSlide = slide.getNotesSlide();

Then retrieve the text from its notes text frame.

The following example loops through the entire presentation and prints the notes for each slide:

import com.spire.presentation.*;

public class ReadSpeakerNotes {

    public static void main(String[] args) throws Exception {

        // Load the PowerPoint presentation
        Presentation presentation = new Presentation();
        presentation.loadFromFile("PresentationWithNotes.pptx");

        // Loop through all slides
        for (int i = 0; i < presentation.getSlides().getCount(); i++) {

            ISlide slide = presentation.getSlides().get(i);
            NotesSlide notesSlide = slide.getNotesSlide();

            // Some slides may not contain speaker notes
            if (notesSlide != null) {

                String notes = notesSlide
                        .getNotesTextFrame()
                        .getText();

                System.out.println(
                        "Slide " + (i + 1) + ":\n" + notes
                );
            }
        }

        presentation.dispose();
    }
}

One detail worth keeping is the null check:

if (notesSlide != null) {
    // Read the notes
}

Not every slide in a presentation necessarily has speaker notes. When processing PowerPoint files from unknown sources, assuming that a notes slide always exists can cause the program to fail when it reaches a slide without notes.

For a presentation containing notes on only some slides, the output might look like this:

Slide 1:
Key message:
Explain that the increase was mainly driven by enterprise customers.
Mention the regional breakdown before moving to the next slide.

Slide 3:
Remind the audience that these figures are preliminary.

After extraction, the notes can be written to a text file, stored in a database, indexed for search, or passed to another part of the application.

This can be useful for reviewing large presentation libraries because the presenter instructions can be collected without opening every slide deck manually.

Remove Speaker Notes from PowerPoint

There are also situations where speaker notes should be removed before a presentation is distributed.

An internal presentation, for example, may contain reminders such as:

Do not discuss pricing unless the customer asks.

or:

Mention that these figures have not been approved yet.

Those notes may be useful during internal meetings but inappropriate in a presentation that will be shared with customers or external partners.

To remove all note paragraphs from a slide, clear the paragraph collection in the notes text frame:

notesSlide.getNotesTextFrame()
        .getParagraphs()
        .clear();

The following example removes speaker-note text from every slide in the presentation:

import com.spire.presentation.*;

public class RemoveSpeakerNotes {

    public static void main(String[] args) throws Exception {

        // Load the presentation
        Presentation presentation = new Presentation();
        presentation.loadFromFile("PresentationWithNotes.pptx");

        // Process all slides
        for (int i = 0; i < presentation.getSlides().getCount(); i++) {

            ISlide slide = presentation.getSlides().get(i);
            NotesSlide notesSlide = slide.getNotesSlide();

            if (notesSlide != null) {

                // Remove all note paragraphs
                notesSlide.getNotesTextFrame()
                        .getParagraphs()
                        .clear();
            }
        }

        // Save the cleaned presentation
        presentation.saveToFile(
                "PresentationWithoutNotes.pptx",
                FileFormat.PPTX_2013
        );

        presentation.dispose();
    }
}

If you only want to remove a specific paragraph rather than clearing all notes, use removeAt():

notesSlide.getNotesTextFrame()
        .getParagraphs()
        .removeAt(1);

The paragraph collection uses a zero-based index, so removeAt(1) removes the second paragraph.

This gives you more control when the notes contain multiple pieces of information and only part of them should be deleted.

Add Notes to Multiple Slides

When presentations are generated automatically, speaker notes often come from the same data source as the visible slide content.

Suppose each slide has a corresponding presenter instruction stored in an array:

String[] speakerNotes = {
        "Introduce the overall project status.",
        "Explain the reason for the schedule change.",
        "Review the three main risks with the audience."
};

You can loop through the slides and insert the corresponding note:

for (int i = 0;
     i < presentation.getSlides().getCount()
             && i < speakerNotes.length;
     i++) {

    ISlide slide = presentation.getSlides().get(i);

    NotesSlide notesSlide = slide.getNotesSlide();

    if (notesSlide == null) {
        notesSlide = slide.addNotesSlide();
    }

    ParagraphEx paragraph = new ParagraphEx();
    paragraph.setText(speakerNotes[i]);

    notesSlide.getNotesTextFrame()
            .getParagraphs()
            .append(paragraph);
}

Here, the code checks whether the slide already has a notes slide before creating one:

if (notesSlide == null) {
    notesSlide = slide.addNotesSlide();
}

This is useful when modifying existing presentations because some slides may already contain notes while others do not.

It also prevents the program from assuming that every presentation starts from a completely blank notes state.

In a real application, the notes do not have to come from an array. They could come from JSON data, a database, an Excel file, an API response, or the same template data used to generate the slide itself.

For example, a training platform might store:

Slide title
Slide content
Instructor note

as separate fields for each training section. The visible content can then be written to the slide while the instructor note is stored as speaker notes.

Speaker Notes vs. Comments

Speaker notes and PowerPoint comments may both contain information that is not part of the visible slide content, but they serve different purposes.

Speaker notes are generally intended for the person presenting the slide deck. They often contain:

Talking points
Additional explanations
Reminders
Supporting facts
Transition cues
Instructions for demonstrations

Comments are mainly used during editing and review. They are more appropriate for feedback such as:

Replace this chart with the latest version.

or:

Please verify the Q3 revenue figure.

So if the information describes what the presenter should say, speaker notes are usually the better place for it.

If the information describes what another editor should change, a comment is generally more appropriate.

Keeping the two types of information separate also helps when presentations are processed automatically. An application can extract presenter instructions without mixing them with review comments.

Things to Consider When Processing Existing Presentations

When working with PowerPoint files created by other users, there are a few practical details worth considering.

First, not every slide has a notes slide. Always check whether getNotesSlide() returns null before attempting to read or modify the notes.

Second, existing notes may contain multiple paragraphs. Calling clear() removes all of them, so use removeAt() instead if only a specific paragraph should be deleted.

Finally, speaker notes may contain information that is not visible during a normal slide show but is still stored in the presentation file. If a presentation is being prepared for external distribution, checking the notes before sharing the file can help prevent internal instructions or unfinished remarks from being included accidentally.

How to Add Page Numbers to PDF in Java (Step-by-Step)

Leon Davis — Fri, 14 Aug 2026 10:56:26 +0000

Page numbers are a small detail, but they become important in reports, contracts, manuals, and other multi-page PDFs. They make printed documents easier to navigate and give reviewers a simple way to refer to a specific page.

When PDFs are generated or processed in a Java application, adding page numbers manually is not practical. A better approach is to add them programmatically after the document has been created or assembled.

In this article, we'll use Spire.PDF for Java to add dynamic page numbers in the format Page 1 of 10 to an existing PDF.

Install Spire.PDF for Java

If you use Maven, add the repository and Spire.PDF 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.8.1</version>
    </dependency>
</dependencies>

Add "Page X of Y" to a PDF in Java

Spire.PDF for Java provides three useful classes for dynamic page numbering:

PdfPageNumberField represents the current page number.
PdfPageCountField represents the total number of pages.
PdfCompositeField combines these values into text such as Page 2 of 10.

This means you don't need to create a different page-number string for every page manually.

The following example adds a centered page number near the bottom of every page:

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.automaticfields.PdfCompositeField;
import com.spire.pdf.automaticfields.PdfPageCountField;
import com.spire.pdf.automaticfields.PdfPageNumberField;
import com.spire.pdf.graphics.PdfBrush;
import com.spire.pdf.graphics.PdfBrushes;
import com.spire.pdf.graphics.PdfTrueTypeFont;

import java.awt.Font;
import java.awt.geom.Dimension2D;
import java.awt.geom.Point2D;

public class AddPageNumbers {

    public static void main(String[] args) {

        // Load the PDF document
        PdfDocument document = new PdfDocument();
        document.loadFromFile("input.pdf");

        // Set the font and color of the page number
        PdfTrueTypeFont font = new PdfTrueTypeFont(
                new Font("Arial", Font.PLAIN, 10), true);
        PdfBrush brush = PdfBrushes.getBlack();

        // Create fields for the current page number and total page count
        PdfPageNumberField pageNumberField = new PdfPageNumberField();
        PdfPageCountField pageCountField = new PdfPageCountField();

        // Combine the fields into "Page X of Y"
        PdfCompositeField pageNumber = new PdfCompositeField(
                font,
                brush,
                "Page {0} of {1}",
                pageNumberField,
                pageCountField
        );

        // Add the page number to each page
        for (int i = 0; i < document.getPages().getCount(); i++) {

            PdfPageBase page = document.getPages().get(i);
            Dimension2D pageSize = page.getSize();

            // Measure the displayed text so it can be centered
            String text = String.format(
                    "Page %d of %d",
                    i + 1,
                    document.getPages().getCount()
            );

            Dimension2D textSize = font.measureString(text);

            // Calculate the position at the bottom center of the page
            double x = (pageSize.getWidth() - textSize.getWidth()) / 2;
            double y = pageSize.getHeight() - 30;

            // Draw the page number
            pageNumber.setLocation(
                    new Point2D.Float((float) x, (float) y)
            );
            pageNumber.draw(page.getCanvas());
        }

        // Save the result
        document.saveToFile("output.pdf");
        document.dispose();
    }
}

The implementation is fairly short, but there are a few details worth understanding.

Step 1: Load the Existing PDF

Start by creating a PdfDocument object and loading the source PDF:

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

This approach works for an existing PDF as well as a document generated earlier in the same application. The page-numbering code only needs to run before the final PDF is saved.

Step 2: Define the Page Number Appearance

Next, create a font and brush:

PdfTrueTypeFont font = new PdfTrueTypeFont(
        new Font("Arial", Font.PLAIN, 10), true);

PdfBrush brush = PdfBrushes.getBlack();

These settings control the font, size, style, and color of the page number.

For most reports, a relatively small font works well in the footer. You can change the font and size to match the rest of the document.

If the application runs on Linux or a server, make sure the font specified in the code is available in that environment. Otherwise, use a font that is installed on the target system.

Step 3: Create Dynamic Page Number Fields

Instead of calculating the page number and total page count yourself, create two automatic fields:

PdfPageNumberField pageNumberField = new PdfPageNumberField();
PdfPageCountField pageCountField = new PdfPageCountField();

PdfPageNumberField supplies the current page number, while PdfPageCountField supplies the total number of pages. Spire.PDF provides these fields specifically for dynamic information added to PDF pages.

They can then be combined with PdfCompositeField:

PdfCompositeField pageNumber = new PdfCompositeField(
        font,
        brush,
        "Page {0} of {1}",
        pageNumberField,
        pageCountField
);

Here, {0} is replaced by the current page number and {1} by the total page count.

For an eight-page PDF, the result will look like:

Page 1 of 8
Page 2 of 8
Page 3 of 8
...
Page 8 of 8

This is more convenient than preparing a separate string for every page, especially when the final page count is not known in advance.

Step 4: Process Each Page Separately

Next, iterate through the PDF:

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

    PdfPageBase page = document.getPages().get(i);
    Dimension2D pageSize = page.getSize();

    // ...
}

The page size is read inside the loop instead of assuming that every page has identical dimensions.

That matters when a PDF contains a mix of portrait and landscape pages or pages with different sizes. Each page can then have its page-number position calculated independently.

Step 5: Center the Page Number at the Bottom

To center the page number properly, first measure the text that will appear on the current page:

String text = String.format(
        "Page %d of %d",
        i + 1,
        document.getPages().getCount()
);

Dimension2D textSize = font.measureString(text);

Then calculate its coordinates:

double x = (pageSize.getWidth() - textSize.getWidth()) / 2;
double y = pageSize.getHeight() - 30;

The X coordinate centers the text horizontally, while the Y coordinate places it near the bottom of the page.

For existing PDFs, Spire.PDF uses a coordinate system whose origin is at the top-left corner. X increases to the right and Y increases downward, which is why a value close to the page height places the page number near the footer.

Finally, set the position and draw the field:

pageNumber.setLocation(
        new Point2D.Float((float) x, (float) y)
);

pageNumber.draw(page.getCanvas());

Because the position is calculated for each page, the page number remains centered even when page dimensions vary.

Change the Page Number Format

The displayed format is controlled by the format string passed to PdfCompositeField.

For example:

"Page {0}"

produces:

Page 1
Page 2
Page 3

For a shorter style, use:

"{0} / {1}"

which produces:

1 / 10

You can also combine page numbers with fixed footer text:

"Project Report | Page {0} of {1}"

The dynamic fields remain the same, so changing the format does not require changing the rest of the page-numbering logic.

Make Sure the Footer Has Enough Space

When adding page numbers to an existing PDF, check whether the bottom of the page already contains text, tables, signatures, or other content.

Drawing a page number does not automatically create extra footer space. If the original content already extends close to the bottom edge, the page number may overlap it.

In that case, adjust the Y coordinate:

double y = pageSize.getHeight() - 30;

to place the page number in a clearer area.

If you also control how the PDF is originally generated, reserving some footer space from the beginning is usually a better solution.

Conclusion

Adding page numbers programmatically is useful when reports, contracts, manuals, or other PDFs are generated in batches or assembled dynamically.

With Spire.PDF for Java, PdfPageNumberField and PdfPageCountField provide the current page number and total page count, while PdfCompositeField combines them into formats such as Page X of Y.

By calculating the position for each page, the same approach also works with PDFs that contain different page sizes or orientations. From there, the footer can be further customized with different formats, fonts, positions, or additional text.

How to Add, Edit, and Remove PDF Bookmarks in Java

Leon Davis — Fri, 07 Aug 2026 11:32:29 +0000

In long PDF documents such as project reports, product manuals, technical specifications, or contract collections, navigating page by page can quickly become inconvenient.

Bookmarks provide a simple way to organize the document structure and let readers jump directly to important sections from the navigation panel. Existing PDFs may also need bookmark maintenance when chapter names change, sections are removed, or the original bookmark structure is no longer accurate.

This article shows how to manage PDF bookmarks in Java, including how to:

Add bookmarks to a PDF
Create multi-level bookmarks
Edit existing bookmarks
Remove individual or all bookmarks

Install the Required PDF Library

This article uses Spire.PDF for Java to read and modify PDF files. It provides APIs for creating top-level and child bookmarks, changing bookmark properties, and removing existing bookmarks.

If you are using Maven, add the 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.6.1</version>
    </dependency>
</dependencies>

You can replace the version number with the current version used in your project.

After installing the library, load an existing PDF with PdfDocument and work with its bookmark collection.

Add Bookmarks to a PDF

Suppose a project report contains the following major sections:

Project Overview
Implementation Plan
Data Analysis
Recommendations

You can create one top-level bookmark for each section and link it to the corresponding page.

The following example adds bookmarks for the first four pages of a PDF.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.actions.PdfGoToAction;
import com.spire.pdf.bookmarks.PdfBookmark;
import com.spire.pdf.bookmarks.PdfTextStyle;
import com.spire.pdf.general.PdfDestination;
import com.spire.pdf.graphics.PdfRGBColor;

import java.awt.Color;
import java.awt.geom.Point2D;

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

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

        // Load the source PDF
        pdf.loadFromFile("ProjectReport.pdf");

        // Define bookmark titles
        String[] bookmarkTitles = {
                "Project Overview",
                "Implementation Plan",
                "Data Analysis",
                "Recommendations"
        };

        // Add bookmarks for the first four pages
        for (int i = 0; i < bookmarkTitles.length; i++) {

            PdfPageBase page = pdf.getPages().get(i);

            // Add a bookmark
            PdfBookmark bookmark =
                    pdf.getBookmarks().add(bookmarkTitles[i]);

            // Set the bookmark destination
            PdfDestination destination =
                    new PdfDestination(
                            page,
                            new Point2D.Float(0, 0)
                    );

            bookmark.setAction(
                    new PdfGoToAction(destination)
            );

            // Set the bookmark color
            bookmark.setColor(
                    new PdfRGBColor(
                            new Color(47, 84, 150)
                    )
            );

            // Display the bookmark in bold
            bookmark.setDisplayStyle(
                    PdfTextStyle.Bold
            );
        }

        // Save the result
        pdf.saveToFile("ProjectReportWithBookmarks.pdf");

        pdf.close();
    }
}

The process consists of three main parts.

First, create a bookmark in the document bookmark collection:

pdf.getBookmarks().add("Project Overview");

Next, create a PdfDestination that identifies the target page and position:

PdfDestination destination =
        new PdfDestination(
                page,
                new Point2D.Float(0, 0)
        );

Finally, connect the bookmark to that destination:

bookmark.setAction(
        new PdfGoToAction(destination)
);

One detail worth noting is that PDF page indexes start from 0.

For example:

get(0) → Page 1
get(1) → Page 2
get(2) → Page 3

If the actual chapter starts on another page, adjust the page index accordingly.

Create Multi-Level PDF Bookmarks

A single level of bookmarks may not be enough for a document with multiple sections and subsections.

For example:

Implementation Plan
├── Project Schedule
├── Team Assignment
└── Risk Management

In this case, child bookmarks can be added under a parent bookmark.

The following example creates one top-level bookmark and three child bookmarks.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.actions.PdfGoToAction;
import com.spire.pdf.bookmarks.PdfBookmark;
import com.spire.pdf.general.PdfDestination;

import java.awt.geom.Point2D;

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

        PdfDocument pdf = new PdfDocument();
        pdf.loadFromFile("ProjectReport.pdf");

        // Create the parent bookmark
        PdfBookmark parentBookmark =
                pdf.getBookmarks().add("Implementation Plan");

        // Link the parent bookmark to page 2
        PdfPageBase parentPage =
                pdf.getPages().get(1);

        PdfDestination parentDestination =
                new PdfDestination(
                        parentPage,
                        new Point2D.Float(0, 0)
                );

        parentBookmark.setAction(
                new PdfGoToAction(parentDestination)
        );

        // Add child bookmark: Project Schedule
        PdfBookmark scheduleBookmark =
                parentBookmark.add("Project Schedule");

        PdfDestination scheduleDestination =
                new PdfDestination(
                        pdf.getPages().get(1),
                        new Point2D.Float(0, 120)
                );

        scheduleBookmark.setAction(
                new PdfGoToAction(scheduleDestination)
        );

        // Add child bookmark: Team Assignment
        PdfBookmark teamBookmark =
                parentBookmark.add("Team Assignment");

        PdfDestination teamDestination =
                new PdfDestination(
                        pdf.getPages().get(2),
                        new Point2D.Float(0, 0)
                );

        teamBookmark.setAction(
                new PdfGoToAction(teamDestination)
        );

        // Add child bookmark: Risk Management
        PdfBookmark riskBookmark =
                parentBookmark.add("Risk Management");

        PdfDestination riskDestination =
                new PdfDestination(
                        pdf.getPages().get(3),
                        new Point2D.Float(0, 0)
                );

        riskBookmark.setAction(
                new PdfGoToAction(riskDestination)
        );

        pdf.saveToFile("ProjectReportWithNestedBookmarks.pdf");

        pdf.close();
    }
}

The important difference is that child bookmarks are added to the parent bookmark:

parentBookmark.add("Project Schedule");

rather than directly to:

pdf.getBookmarks()

This creates a real hierarchical bookmark structure.

For reports and manuals that already follow a chapter-and-section structure, multi-level bookmarks are usually easier to navigate than a long flat list.

Edit Existing PDF Bookmarks

PDF content often changes over time.

For example, a section originally named:

Project Plan

may later be renamed to:

Project Implementation Plan

If the PDF pages have already been updated, the bookmark can be edited directly instead of rebuilding the entire file.

The following example changes the title, color, and display style of the first bookmark.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.bookmarks.PdfBookmark;
import com.spire.pdf.bookmarks.PdfTextStyle;
import com.spire.pdf.graphics.PdfRGBColor;

import java.awt.Color;

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

        PdfDocument pdf = new PdfDocument();

        // Load a PDF that already contains bookmarks
        pdf.loadFromFile("ProjectReport.pdf");

        // Get the first bookmark
        PdfBookmark bookmark =
                pdf.getBookmarks().get(0);

        // Change the bookmark title
        bookmark.setTitle("Project Implementation Plan");

        // Change the bookmark color
        bookmark.setColor(
                new PdfRGBColor(
                        new Color(31, 78, 121)
                )
        );

        // Display it in bold
        bookmark.setDisplayStyle(
                PdfTextStyle.Bold
        );

        // Save the result
        pdf.saveToFile("ProjectReportWithUpdatedBookmark.pdf");

        pdf.close();
    }
}

If only the title needs to change, the essential code is simply:

bookmark.setTitle("New Section Title");

Changing the color or text style is optional and depends on how the bookmark panel should be presented.

Remove a Specific PDF Bookmark

If a section has been removed from the document, its bookmark should usually be removed as well.

Otherwise, the bookmark may still point to a page that no longer represents the expected content.

A top-level bookmark can be removed with:

pdf.getBookmarks().removeAt(0);

For example:

import com.spire.pdf.PdfDocument;

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

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("ProjectReport.pdf");

        // Remove the first top-level bookmark
        pdf.getBookmarks().removeAt(0);

        pdf.saveToFile("ProjectReportAfterBookmarkRemoval.pdf");

        pdf.close();
    }
}

The index also starts from 0, so removeAt(0) removes the first top-level bookmark.

If that bookmark contains child bookmarks, removing the parent also removes the bookmarks under it.

Remove a Child Bookmark

Sometimes only one subsection needs to be removed while the parent bookmark should remain.

In that case, get the parent bookmark first and remove the required child bookmark from it.

PdfBookmark parentBookmark =
        pdf.getBookmarks().get(0);

// Remove the first child bookmark
parentBookmark.removeAt(0);

This changes a structure such as:

Implementation Plan
├── Project Schedule   ← removed
├── Team Assignment
└── Risk Management

without deleting the entire Implementation Plan bookmark.

This is useful when only part of the document structure changes.

Remove All Bookmarks from a PDF

If the existing bookmark structure is completely outdated, it may be simpler to remove all bookmarks and rebuild them from scratch.

Use:

pdf.getBookmarks().clear();

A complete example looks like this:

import com.spire.pdf.PdfDocument;

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

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("ProjectReport.pdf");

        // Remove all bookmarks
        pdf.getBookmarks().clear();

        pdf.saveToFile("ProjectReportWithoutBookmarks.pdf");

        pdf.close();
    }
}

This approach is useful when:

The existing bookmark structure is no longer valid
The document has been reorganized significantly
Bookmarks need to be regenerated from a new table of contents
PDFs from different sources contain inconsistent bookmark structures

Practical Considerations

1. Remember That Page Indexes Start from 0

This is one of the easiest mistakes to make when assigning bookmark destinations.

If a business rule says that a bookmark should point to page 5, the corresponding code is:

pdf.getPages().get(4);

If page numbers are stored externally as normal one-based numbers, convert them before accessing the PDF page collection:

int pageIndex = pageNumber - 1;

This is particularly important when generating many bookmarks automatically.

2. Validate the Target Page Before Creating a Bookmark

If bookmark definitions come from a database, configuration file, or another external source, do not assume that every page number is valid.

For example:

int pageIndex = 10;

if (pageIndex >= 0 &&
        pageIndex < pdf.getPages().getCount()) {

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

    // Create the bookmark here
}

This avoids failures caused by invalid page references.

3. Keep Bookmark Titles Consistent with the Document Structure

If a visible section heading is:

3. Project Implementation Plan

but the bookmark is simply:

Plan

the bookmark technically works, but the navigation structure becomes less clear.

For automatically generated reports, it is usually better to reuse the same chapter titles for both the document body and the bookmarks.

For example:

String[] chapterNames = {
        "1. Project Overview",
        "2. Implementation Plan",
        "3. Data Analysis",
        "4. Recommendations"
};

This makes the document body, table of contents, and bookmark panel easier to keep consistent.

4. Avoid Excessively Deep Bookmark Hierarchies

PDF bookmarks support nested levels, but a very deep structure can become difficult to use.

For many reports and manuals, a structure such as:

Chapter
└── Section

or:

Chapter
└── Section
    └── Subsection

is usually enough.

If the source data contains six or seven hierarchical levels, consider exposing only the most useful levels as PDF bookmarks rather than reproducing the full internal structure.

Conclusion

Bookmarks provide a practical navigation layer for long PDF documents such as reports, manuals, specifications, and contract collections.

This article covered how to use Java to:

Add top-level bookmarks to a PDF
Create parent-child bookmark structures
Edit bookmark titles and styles
Remove individual top-level or child bookmarks
Remove all bookmarks from a PDF

For automatically generated PDFs, bookmarks can be created from the same chapter names and page information used to build the document. For existing PDFs, outdated bookmark structures can be edited or rebuilt without recreating the entire file.

Keeping the bookmark structure aligned with the actual document makes long PDFs easier to navigate and easier to maintain.

How to Create Drop-Down Lists in Excel with C#

Leon Davis — Fri, 07 Aug 2026 11:26:36 +0000

In employee records, order forms, project trackers, and other Excel templates, some fields should only contain predefined values, such as departments, task statuses, approval results, or product categories.

If users enter these values manually, the same option can easily appear in different forms. For example, a task status might be entered as In Progress, In progress, or an abbreviated variation. This creates extra cleanup work later when the workbook is filtered, summarized, or imported into another system.

Adding drop-down lists to these cells gives users a controlled set of choices and helps reduce inconsistent data at the point of entry.

This article shows how to create Excel drop-down lists in C# in three common scenarios:

Use fixed values as drop-down options
Use a cell range in the current worksheet as the data source
Use data from another worksheet as the drop-down source

Install the Required Excel Library

This article uses Spire.XLS for .NET to create and modify Excel files. It supports Excel data validation, including list-based drop-downs, and does not require Microsoft Excel to be installed on the machine running the code.

You can install it through NuGet Package Manager Console:

Install-Package Spire.XLS

Then import the required namespace:

using Spire.Xls;

The implementation depends mainly on where the drop-down values come from.

Create an Excel Drop-Down List from Fixed Values

If the available options are limited and unlikely to change often, the simplest approach is to define them directly in a string array.

For example, a task management sheet may restrict the task status to:

Not Started
In Progress
Completed
On Hold

The following example creates a simple task table and adds a status drop-down list to cell D2.

using Spire.Xls;

namespace CreateExcelDropdown
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Workbook object
            Workbook workbook = new Workbook();

            // Get the first worksheet
            Worksheet sheet = workbook.Worksheets[0];
            sheet.Name = "Task Management";

            // Add headers
            sheet.Range["A1"].Text = "Task ID";
            sheet.Range["B1"].Text = "Task Name";
            sheet.Range["C1"].Text = "Owner";
            sheet.Range["D1"].Text = "Status";

            // Add sample data
            sheet.Range["A2"].Text = "T001";
            sheet.Range["B2"].Text = "Prepare Project Plan";
            sheet.Range["C2"].Text = "Alice Johnson";

            // Define drop-down options
            string[] statusValues =
            {
                "Not Started",
                "In Progress",
                "Completed",
                "On Hold"
            };

            // Apply the drop-down list to D2
            sheet.Range["D2"].DataValidation.Values = statusValues;

            // Auto-fit columns
            sheet.AllocatedRange.AutoFitColumns();

            // Save the workbook
            workbook.SaveToFile(
                "TaskStatusDropdown.xlsx",
                ExcelVersion.Version2016);

            workbook.Dispose();
        }
    }
}

The key line is:

sheet.Range["D2"].DataValidation.Values = statusValues;

DataValidation.Values accepts a string array and uses the array items as the available list values.

This approach works well for fixed choices such as:

Status
Priority
Enabled / Disabled
Approval result
Fixed categories

If the options are numerous or change frequently, hard-coding them in the application is less convenient. In that case, storing the values in worksheet cells is usually easier to maintain.

Create a Drop-Down List from a Cell Range

Sometimes the available options already exist inside the workbook.

For example, an employee worksheet may contain a department list in F2:F5:

Cell	Value
F2	Sales
F3	Finance
F4	IT
F5	Human Resources

The Department field can then use that range as its drop-down source.

using Spire.Xls;

namespace CreateDropdownFromRange
{
    class Program
    {
        static void Main(string[] args)
        {
            Workbook workbook = new Workbook();

            Worksheet sheet = workbook.Worksheets[0];
            sheet.Name = "Employees";

            // Create the employee table
            sheet.Range["A1"].Text = "Employee ID";
            sheet.Range["B1"].Text = "Employee Name";
            sheet.Range["C1"].Text = "Department";

            sheet.Range["A2"].Text = "E001";
            sheet.Range["B2"].Text = "John Smith";

            // Create the department source list
            sheet.Range["F1"].Text = "Department List";
            sheet.Range["F2"].Text = "Sales";
            sheet.Range["F3"].Text = "Finance";
            sheet.Range["F4"].Text = "IT";
            sheet.Range["F5"].Text = "Human Resources";

            // Get the source range
            CellRange departmentRange = sheet.Range["F2:F5"];

            // Use the range as the drop-down source
            sheet.Range["C2"].DataValidation.DataRange =
                departmentRange;

            sheet.AllocatedRange.AutoFitColumns();

            workbook.SaveToFile(
                "DepartmentDropdown.xlsx",
                ExcelVersion.Version2016);

            workbook.Dispose();
        }
    }
}

The main difference here is:

sheet.Range["C2"].DataValidation.DataRange = departmentRange;

Using a worksheet range as the data source makes the list easier to maintain.

For example, if another department is added later, the source data can be updated in the workbook rather than duplicated as a long list of hard-coded values in C#.

This approach is useful when the source values already belong to the same worksheet.

In larger business templates, however, storing helper values beside the main data can make the sheet look cluttered. A more common design is to keep these values on a separate worksheet.

Create a Drop-Down List from Another Worksheet

In real-world templates, business data and lookup values are often stored separately.

For example, a workbook might contain:

Employees: stores employee information
Options: stores departments, job titles, statuses, and other lookup values

This keeps the main worksheet cleaner and makes the source values easier to manage.

The following example creates a drop-down list whose values come from another worksheet.

using Spire.Xls;

namespace CreateCrossSheetDropdown
{
    class Program
    {
        static void Main(string[] args)
        {
            Workbook workbook = new Workbook();

            // Get the employee worksheet
            Worksheet employeeSheet = workbook.Worksheets[0];
            employeeSheet.Name = "Employees";

            // Add the options worksheet
            Worksheet optionsSheet =
                workbook.Worksheets.Add("Options");

            // -------------------------
            // Employees worksheet
            // -------------------------

            employeeSheet.Range["A1"].Text = "Employee ID";
            employeeSheet.Range["B1"].Text = "Employee Name";
            employeeSheet.Range["C1"].Text = "Department";

            employeeSheet.Range["A2"].Text = "E001";
            employeeSheet.Range["B2"].Text = "John Smith";

            // -------------------------
            // Options worksheet
            // -------------------------

            optionsSheet.Range["A1"].Text = "Department List";
            optionsSheet.Range["A2"].Text = "Sales";
            optionsSheet.Range["A3"].Text = "Finance";
            optionsSheet.Range["A4"].Text = "IT";
            optionsSheet.Range["A5"].Text = "Human Resources";

            // Allow data validation to reference another worksheet
            workbook.Allow3DRangesInDataValidation = true;

            // Get the department source range
            CellRange departmentRange =
                optionsSheet.Range["A2:A5"];

            // Apply the source range to the Department field
            employeeSheet.Range["C2"]
                .DataValidation.DataRange = departmentRange;

            employeeSheet.AllocatedRange.AutoFitColumns();
            optionsSheet.AllocatedRange.AutoFitColumns();

            workbook.SaveToFile(
                "CrossSheetDropdown.xlsx",
                ExcelVersion.Version2016);

            workbook.Dispose();
        }
    }
}

One setting is easy to overlook when the validation source is on another worksheet:

workbook.Allow3DRangesInDataValidation = true;

This allows the data validation rule to reference a range outside the current worksheet.

After enabling it, you can set the source range normally:

employeeSheet.Range["C2"].DataValidation.DataRange =
    optionsSheet.Range["A2:A5"];

This layout works well for business templates that need centrally maintained lookup values.

A workbook might be organized like this:

Workbook
│
├── Employees
│   ├── Employee ID
│   ├── Employee Name
│   └── Department ▼
│
└── Options
    ├── Sales
    ├── Finance
    ├── IT
    └── Human Resources

If end users do not need to see the helper data, the Options worksheet can also be hidden.

Apply the Same Drop-Down List to Multiple Cells

The previous examples apply data validation to a single cell, but real templates usually need the same list across many rows.

For example, to apply the department list to C2:C100:

employeeSheet.Range["C2:C100"]
    .DataValidation.DataRange = departmentRange;

The same approach works with fixed values:

string[] statusValues =
{
    "Not Started",
    "In Progress",
    "Completed",
    "On Hold"
};

sheet.Range["D2:D100"].DataValidation.Values =
    statusValues;

Applying validation to a range is simpler than looping through cells one by one and is usually a better fit for generated Excel templates.

Which Approach Should You Use?

The main difference between the three approaches is where the drop-down values are stored.

Data Source	Implementation	Best For
Fixed strings	`DataValidation.Values`	Status, priority, approval results, and other fixed options
Current worksheet range	`DataValidation.DataRange`	Simple templates with a small amount of helper data
Another worksheet	`DataValidation.DataRange` + `Allow3DRangesInDataValidation`	Business templates with centrally managed lookup values

For a small fixed set such as Yes / No or Enabled / Disabled, a string array is usually the simplest choice.

If the values change regularly or come from business data, using a cell range is easier to maintain.

For long-lived templates such as employee forms, order forms, or project tracking workbooks, keeping lookup values on a dedicated worksheet is often the cleaner approach.

Practical Considerations

1. Avoid Hard-Coding Frequently Changing Options

Suppose a department list originally contains:

Sales
Finance
IT

and later needs:

Customer Service

If the entire list is hard-coded in C#, the application must be updated and redeployed.

If the values come from a database, configuration source, or admin system, a more maintainable workflow is:

Read the latest values from the business system
Write them to an Options worksheet
Point the data validation rule to that range

This keeps the generated workbook aligned with the current business data.

2. Keep the Source Range in Sync

If the drop-down list points to:

A2:A5

but the actual list later grows to A8, the new values will not appear unless the validation source range is updated.

For dynamic data, calculate the final row when generating the workbook.

For example:

int lastRow = 8;

employeeSheet.Range["C2:C100"]
    .DataValidation.DataRange =
    optionsSheet.Range["A2:A" + lastRow];

This makes the source range follow the actual number of available options.

3. Excel Drop-Down Lists Do Not Replace Server-Side Validation

Excel data validation helps reduce user input errors, but it should not be treated as the only validation layer if the data will later be imported into a database or business system.

For example, even if the Department field uses a drop-down list, the import process can still verify that the selected department is currently valid.

This is important because Excel validation can sometimes be bypassed through copy and paste, external editing tools, or direct file manipulation.

4. Dependent Drop-Down Lists Require Additional Logic

Some lists depend on a previous selection, for example:

Country → City
Product Category → Product
Department → Job Title

A simple fixed list is not enough in these cases.

Dependent drop-downs usually require a combination of:

Named ranges
Data validation formulas
Excel functions such as INDIRECT

It is therefore worth deciding whether the options are independent or hierarchical before designing the workbook template.

Conclusion

Drop-down lists are a practical way to improve data consistency in Excel templates generated with C#.

This article covered three common approaches:

Creating a drop-down list from fixed string values
Using a cell range in the current worksheet as the data source
Referencing values stored on another worksheet

For small and stable option sets, a string array is usually sufficient. For values that need regular maintenance or come from business systems, storing the options in worksheet cells and using them as the validation source is generally more flexible.

Choosing the data source based on how the options are maintained makes the resulting Excel file easier to use and easier to keep in sync with the rest of the application.

How to Create and Update a Table of Contents in Word Using Java

Leon Davis — Fri, 31 Jul 2026 12:57:03 +0000

Project reports, product manuals, technical documents, and other long-form Word files often contain multiple chapters and sections. As the content changes, section titles, chapter order, and page numbers may also change.

Maintaining the table of contents manually is repetitive and can easily result in missing headings or incorrect page numbers.

A Word table of contents is a field generated from the heading styles used in the document. As long as the document uses Heading 1, Heading 2, Heading 3, and other built-in heading styles correctly, the table of contents can be inserted programmatically and updated after the document changes.

This article demonstrates how to use Java to:

Create a Word document with multilevel headings
Generate a table of contents from Heading 1 through Heading 3
Insert a table of contents into an existing Word document
Update heading text and page numbers in an existing table of contents
Control which heading levels appear in the table of contents

How Word Identifies Headings for a Table of Contents

A Word table of contents normally uses paragraph styles to determine the heading hierarchy.

For example:

Document Content	Word Style	TOC Level
1. Project Overview	Heading 1	Level 1
1.1 Project Background	Heading 2	Level 2
1.1.1 Project Goals	Heading 3	Level 3

Making text bold or increasing its font size does not automatically make it a heading. The paragraph must use an actual Word heading style.

In Java, the following built-in styles can be applied:

BuiltinStyle.Heading_1
BuiltinStyle.Heading_2
BuiltinStyle.Heading_3

The appendTOC() method specifies the heading levels included in the table of contents, while updateTableOfContents() recalculates the entries and page numbers based on the current document structure.

Install the Word Library

The examples below use Spire.Doc for Java to create and edit Word documents.

Add the following repository and dependency to the pom.xml file of a Maven project:

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

The version number can be changed to the version currently used in your project.

Import the required classes:

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

Create a Word Document with a Table of Contents in Java

The following example creates a Word document from scratch and inserts a table of contents containing Heading 1 through Heading 3.

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

public class CreateWordWithToc {

    public static void main(String[] args) {

        // Create a Word document
        Document document = new Document();

        try {
            // Add a section
            Section section = document.addSection();

            // Add the table of contents title
            Paragraph tocTitle = section.addParagraph();
            TextRange titleText = tocTitle.appendText(
                    "Table of Contents"
            );

            titleText.getCharacterFormat().setBold(true);
            titleText.getCharacterFormat().setFontSize(18);

            tocTitle.getFormat().setHorizontalAlignment(
                    HorizontalAlignment.Center
            );

            // Insert a table of contents containing
            // Heading 1 through Heading 3
            Paragraph tocParagraph = section.addParagraph();
            tocParagraph.appendTOC(1, 3);

            // Insert a page break after the table of contents
            tocParagraph.appendBreak(BreakType.Page_Break);

            // Add a level-one heading
            addHeading(
                    section,
                    "1. Project Overview",
                    BuiltinStyle.Heading_1
            );

            addBodyText(
                    section,
                    "This chapter introduces the project background, "
                            + "main objectives, and implementation scope."
            );

            // Add level-two headings
            addHeading(
                    section,
                    "1.1 Project Background",
                    BuiltinStyle.Heading_2
            );

            addBodyText(
                    section,
                    "As the scale of the business grows, the existing "
                            + "management approach is no longer sufficient "
                            + "for centralized operations."
            );

            addHeading(
                    section,
                    "1.2 Project Objectives",
                    BuiltinStyle.Heading_2
            );

            addBodyText(
                    section,
                    "The project will establish a unified platform for "
                            + "data management and business collaboration."
            );

            // Add level-three headings
            addHeading(
                    section,
                    "1.2.1 Business Objectives",
                    BuiltinStyle.Heading_3
            );

            addBodyText(
                    section,
                    "Standardize business processes and improve "
                            + "cross-department collaboration."
            );

            addHeading(
                    section,
                    "1.2.2 Technical Objectives",
                    BuiltinStyle.Heading_3
            );

            addBodyText(
                    section,
                    "Create a scalable and maintainable system architecture."
            );

            // Add another level-one heading
            addHeading(
                    section,
                    "2. Implementation Plan",
                    BuiltinStyle.Heading_1
            );

            addBodyText(
                    section,
                    "This chapter describes the implementation stages "
                            + "and major project tasks."
            );

            addHeading(
                    section,
                    "2.1 Implementation Stages",
                    BuiltinStyle.Heading_2
            );

            addBodyText(
                    section,
                    "The project includes requirements analysis, "
                            + "system design, development, testing, "
                            + "and deployment."
            );

            // Update the table of contents based on
            // the current headings and pagination
            document.updateTableOfContents();

            // Save the document
            document.saveToFile(
                    "WordDocumentWithTOC.docx",
                    FileFormat.Docx_2019
            );

        } finally {
            document.dispose();
        }
    }

    /**
     * Add a heading paragraph.
     */
    private static void addHeading(
            Section section,
            String text,
            BuiltinStyle style
    ) {
        Paragraph paragraph = section.addParagraph();
        paragraph.appendText(text);
        paragraph.applyStyle(style);
    }

    /**
     * Add a body paragraph.
     */
    private static void addBodyText(
            Section section,
            String text
    ) {
        Paragraph paragraph = section.addParagraph();
        paragraph.appendText(text);
        paragraph.getFormat().setAfterSpacing(10);
    }
}

After the code runs, it creates:

WordDocumentWithTOC.docx

The first page contains the table of contents, while the main document starts on the next page. The table of contents includes level-one, level-two, and level-three headings together with their page numbers.

Understanding the appendTOC() Parameters

The following code creates a table of contents containing Heading 1 through Heading 3:

tocParagraph.appendTOC(1, 3);

The two parameters represent:

Starting heading level
Ending heading level

For example, to include only Heading 1 and Heading 2:

tocParagraph.appendTOC(1, 2);

To include only Heading 1:

tocParagraph.appendTOC(1, 1);

For most project reports and technical documents, three heading levels are usually sufficient. Including too many levels may make the table of contents difficult to scan and unnecessarily long.

Insert a Table of Contents into an Existing Word Document

In many cases, the Word document already contains the main content and only needs a table of contents added at the beginning.

The following example loads an existing Word file and inserts the table of contents at the beginning of the first section.

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

public class AddTocToExistingDocument {

    public static void main(String[] args) {

        Document document = new Document();

        try {
            // Load an existing Word document
            document.loadFromFile("ProjectReport.docx");

            // Get the first section
            Section firstSection =
                    document.getSections().get(0);

            // Create the table of contents title
            Paragraph tocTitle = new Paragraph(document);
            TextRange titleText = tocTitle.appendText(
                    "Table of Contents"
            );

            titleText.getCharacterFormat().setBold(true);
            titleText.getCharacterFormat().setFontSize(18);

            tocTitle.getFormat().setHorizontalAlignment(
                    HorizontalAlignment.Center
            );

            // Create the table of contents paragraph
            Paragraph tocParagraph = new Paragraph(document);
            tocParagraph.appendTOC(1, 3);

            // Insert a page break after the table of contents
            tocParagraph.appendBreak(BreakType.Page_Break);

            // Insert the title and table of contents
            // at the beginning of the first section
            firstSection.getParagraphs().insert(
                    0,
                    tocTitle
            );

            firstSection.getParagraphs().insert(
                    1,
                    tocParagraph
            );

            // Update the table of contents
            document.updateTableOfContents();

            // Save the result as a new file
            document.saveToFile(
                    "ProjectReportWithTOC.docx",
                    FileFormat.Docx_2019
            );

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

The result is saved as a new file instead of overwriting the source document:

ProjectReport.docx
ProjectReportWithTOC.docx

The headings in the original document must already use styles such as Heading 1, Heading 2, and Heading 3. Otherwise, the table of contents field may be inserted successfully but contain few or no entries.

Apply Heading Styles to Ordinary Paragraphs

If the section titles in an existing document are ordinary paragraphs, heading styles can be applied before generating the table of contents.

For example, suppose the third paragraph in the first section is a level-one heading and the fifth paragraph is a level-two heading:

Section section = document.getSections().get(0);

section.getParagraphs()
        .get(2)
        .applyStyle(BuiltinStyle.Heading_1);

section.getParagraphs()
        .get(4)
        .applyStyle(BuiltinStyle.Heading_2);

After applying the styles, insert and update the table of contents:

Paragraph tocParagraph = new Paragraph(document);
tocParagraph.appendTOC(1, 3);

section.getParagraphs().insert(
        0,
        tocParagraph
);

document.updateTableOfContents();

This approach works well with documents that follow a fixed template.

For documents with an unpredictable structure, relying entirely on paragraph indexes is risky. Adding or removing a paragraph changes the indexes of all subsequent paragraphs.

A more reliable approach is to identify headings by their text, existing styles, bookmarks, or other document markers.

Update an Existing Word Table of Contents

When section titles, chapter order, or document length changes, the table of contents should be updated.

The following example changes a heading and then refreshes the table of contents:

import com.spire.doc.Document;
import com.spire.doc.FileFormat;

public class UpdateWordToc {

    public static void main(String[] args) {

        Document document = new Document();

        try {
            // Load a Word document containing a table of contents
            document.loadFromFile(
                    "WordDocumentWithTOC.docx"
            );

            // Change a heading
            document.replace(
                    "2. Implementation Plan",
                    "2. Project Implementation Plan",
                    false,
                    true
            );

            // Update the TOC entries and page numbers
            document.updateTableOfContents();

            // Save the updated document
            document.saveToFile(
                    "UpdatedWordTOC.docx",
                    FileFormat.Docx_2019
            );

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

After the update, the table of contents entry:

2. Implementation Plan

becomes:

2. Project Implementation Plan

If the document changes cause a heading to move to another page, the corresponding page number is recalculated as well.

Prevent the TOC Title from Appearing in the Table of Contents

The table of contents page often includes a title such as “Table of Contents.”

That title should not use the Heading 1 style unless it is intended to appear as an entry inside the table of contents.

Instead, format it manually:

Paragraph tocTitle = section.addParagraph();

TextRange textRange =
        tocTitle.appendText("Table of Contents");

textRange.getCharacterFormat().setBold(true);
textRange.getCharacterFormat().setFontSize(18);

tocTitle.getFormat().setHorizontalAlignment(
        HorizontalAlignment.Center
);

Avoid applying a heading style like this:

tocTitle.applyStyle(BuiltinStyle.Heading_1);

Otherwise, “Table of Contents” may appear as a level-one entry inside the table itself.

Common Problems When Updating a Table of Contents

The Table of Contents Is Empty

This usually means the section headings do not use formal Word heading styles.

Bold text, larger font sizes, or different colors do not make a paragraph part of the heading hierarchy.

Apply an actual heading style:

paragraph.applyStyle(BuiltinStyle.Heading_1);

The same applies to Heading 2, Heading 3, and other levels.

Level-Three Headings Are Missing

Check the ending level passed to appendTOC().

The following code includes only Heading 1 and Heading 2:

tocParagraph.appendTOC(1, 2);

To include Heading 3 as well, use:

tocParagraph.appendTOC(1, 3);

Page Numbers Have Not Changed

After modifying the document content, call:

document.updateTableOfContents();

If the document is saved without updating the table of contents, it may continue to display outdated entries or page numbers.

The Table of Contents Appears Before the Cover Page

If the document contains a cover page, place the table of contents in a separate section after the cover instead of inserting it at the first paragraph of the document.

A suitable document structure is:

Section 1: Cover page
Section 2: Table of contents
Section 3: Main content

This approach is more appropriate for formal reports, proposals, and product manuals.

Heading Numbers Are Duplicated

Heading styles define the hierarchy but do not automatically guarantee that manually entered chapter numbers are correct.

For example:

1. Project Overview
1.1 Project Background

If the numbers are written directly in the heading text, the program must ensure that they match the actual heading hierarchy.

When Word multilevel lists are used for automatic numbering, both the list formatting and heading styles need to be maintained.

Practical Considerations

Use a Consistent Heading Structure

A reliable table of contents depends on a consistent document hierarchy.

For example:

Heading 1: Main chapters
Heading 2: Sections
Heading 3: Subsections

Avoid using the same heading level for unrelated structural purposes.

Save the Output as a New File

When adding or updating a table of contents in an existing document, save the result as a new file:

ProjectReport.docx
ProjectReportWithTOC.docx

This keeps the source document available in case the heading styles, pagination, or table of contents layout need to be adjusted.

Keep the Number of TOC Levels Reasonable

Although Word supports several heading levels, including too many levels may reduce readability.

For most business and technical documents, one to three levels are enough.

Check the Result in Word

Automatic generation can handle the heading entries and page numbers, but the result should still be reviewed in Word.

Pay particular attention to:

Long heading text
Page breaks
Section breaks
Headers and footers
Landscape pages
Tables that affect pagination

Conclusion

Java can be used to automate common Word table of contents operations, including:

Creating Heading 1 through Heading 3 paragraphs
Generating a table of contents from heading styles
Inserting a table of contents into an existing Word document
Updating heading text and page numbers
Controlling which heading levels appear
Placing the table of contents between the cover page and main content

The most important part of the process is not the table of contents field itself, but the document’s heading structure.

When headings use the correct Word styles, updateTableOfContents() can regenerate the entries and page numbers after the document changes, reducing the need for manual maintenance.

How to Add Sparklines to Excel in Python

Leon Davis — Fri, 31 Jul 2026 12:52:54 +0000

Sales reports, inventory sheets, and operational dashboards often contain data that changes over time. Although the values can be compared directly, it may still be difficult to identify growth, decline, or unusual fluctuations across many rows.

A standard Excel chart can make trends easier to understand, but creating a separate chart for every product, department, or project would take up too much space.

Excel sparklines provide a more compact alternative. A sparkline is a small chart displayed inside a single cell, allowing readers to view the trend of a data series without changing the overall worksheet layout.

This article demonstrates how to use Python to:

Create an Excel workbook containing monthly sales data
Add line sparklines to multiple rows
Change sparklines to column or win/loss types
Configure sparkline and high-point colors
Add sparklines to an existing Excel workbook

What Are Excel Sparklines?

Unlike standard Excel charts, a sparkline is usually displayed inside one cell.

For example, consider the following monthly sales data:

Product	Jan	Feb	Mar	Apr	Trend
Product A	120	135	128	160	Sparkline
Product B	95	110	108	126	Sparkline

A sparkline can be placed in the cell next to each row, allowing readers to quickly identify whether the values are increasing, decreasing, or fluctuating.

Excel supports three common sparkline types:

Line sparklines show continuous changes over time, such as sales, website visits, or revenue.
Column sparklines make it easier to compare the relative size of individual values.
Win/loss sparklines emphasize positive and negative results rather than exact values.

Install the Excel Library

The examples below use Spire.XLS for Python to create and edit Excel workbooks.

Install the package with pip:

pip install Spire.XLS

Then import the required modules:

from spire.xls import *
from spire.xls.common import *

Create Sample Excel Data in Python

The following example creates a worksheet containing monthly sales data for four products.

The data is stored in the range A1:N5:

Column A contains product names
Columns B through M contain sales data from January to December
Column N is reserved for sparklines

from spire.xls import *
from spire.xls.common import *

# Create a workbook
workbook = Workbook()

# Get the first worksheet
sheet = workbook.Worksheets[0]
sheet.Name = "Monthly Sales"

# Define the headers
headers = [
    "Product",
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
    "Trend"
]

# Define monthly sales data
sales_data = [
    ["Product A", 120, 135, 128, 160, 172, 168, 190, 205, 198, 220, 235, 248],
    ["Product B", 95, 108, 115, 110, 126, 140, 138, 150, 163, 158, 172, 185],
    ["Product C", 180, 172, 165, 170, 158, 150, 162, 155, 148, 142, 150, 138],
    ["Product D", 75, 92, 88, 105, 98, 115, 121, 118, 132, 140, 137, 152]
]

# Write the headers
for column_index, header in enumerate(headers, start=1):
    sheet.Range[1, column_index].Text = header

# Write the product names and sales values
for row_index, row_data in enumerate(sales_data, start=2):
    sheet.Range[row_index, 1].Text = row_data[0]

    for column_index, value in enumerate(row_data[1:], start=2):
        sheet.Range[row_index, column_index].NumberValue = value

# Make the header row bold
sheet.Range["A1:N1"].Style.Font.IsBold = True

# Automatically adjust the column widths
sheet.Range["A1:N5"].AutoFitColumns()

At this stage, the worksheet contains the complete sales data, but no sparklines have been added yet.

Add Line Sparklines to Excel in Python

To add sparklines, first create a sparkline group and specify its chart type.

The following code adds line sparklines to cells N2:N5. Each sparkline uses the 12 monthly values from the corresponding row.

# Create a sparkline group
sparkline_group = sheet.SparklineGroups.AddGroup()

# Set the sparkline type to line
sparkline_group.SparklineType = SparklineType.Line

# Set the sparkline color
sparkline_group.SparklineColor = Color.get_DarkBlue()

# Set the color of the highest point
sparkline_group.HighPointColor = Color.get_Red()

# Create a sparkline collection
sparklines = sparkline_group.Add()

# Add one sparkline for each product row
for row in range(2, 6):
    data_range = sheet.Range[f"B{row}:M{row}"]
    location = sheet.Range[f"N{row}"]

    sparklines.Add(data_range, location)

The main operations are:

AddGroup() creates a new sparkline group.
SparklineType.Line specifies a line sparkline.
SparklineColor sets the main sparkline color.
HighPointColor sets the color of the highest value.
sparklines.Add() defines the source data and destination cell.

Keeping similar sparklines in one group makes it easier to apply the same type and formatting to all of them.

Save the Excel Workbook

After adding the sparklines, save the workbook as an XLSX file:

# Save the workbook
workbook.SaveToFile(
    "sales_trends_with_sparklines.xlsx",
    ExcelVersion.Version2016
)

# Release resources
workbook.Dispose()

The output file is:

sales_trends_with_sparklines.xlsx

When the file is opened in Excel, column N displays a monthly trend sparkline for each product.

Complete Code Example

The following code combines workbook creation, data entry, sparkline generation, and file saving.

from spire.xls import *
from spire.xls.common import *

# Create a workbook
workbook = Workbook()

# Get the first worksheet
sheet = workbook.Worksheets[0]
sheet.Name = "Monthly Sales"

# Define the headers
headers = [
    "Product",
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
    "Trend"
]

# Define monthly sales data
sales_data = [
    ["Product A", 120, 135, 128, 160, 172, 168, 190, 205, 198, 220, 235, 248],
    ["Product B", 95, 108, 115, 110, 126, 140, 138, 150, 163, 158, 172, 185],
    ["Product C", 180, 172, 165, 170, 158, 150, 162, 155, 148, 142, 150, 138],
    ["Product D", 75, 92, 88, 105, 98, 115, 121, 118, 132, 140, 137, 152]
]

# Write the headers
for column_index, header in enumerate(headers, start=1):
    sheet.Range[1, column_index].Text = header

# Write the data
for row_index, row_data in enumerate(sales_data, start=2):
    # Write the product name
    sheet.Range[row_index, 1].Text = row_data[0]

    # Write the monthly sales values
    for column_index, value in enumerate(row_data[1:], start=2):
        sheet.Range[row_index, column_index].NumberValue = value

# Format the header row
sheet.Range["A1:N1"].Style.Font.IsBold = True

# Create a line sparkline group
sparkline_group = sheet.SparklineGroups.AddGroup()
sparkline_group.SparklineType = SparklineType.Line

# Configure sparkline colors
sparkline_group.SparklineColor = Color.get_DarkBlue()
sparkline_group.HighPointColor = Color.get_Red()

# Create a sparkline collection
sparklines = sparkline_group.Add()

# Add sparklines to cells N2:N5
for row in range(2, 6):
    sparklines.Add(
        sheet.Range[f"B{row}:M{row}"],
        sheet.Range[f"N{row}"]
    )

# Automatically adjust the column widths
sheet.Range["A1:N5"].AutoFitColumns()

# Save the result
workbook.SaveToFile(
    "sales_trends_with_sparklines.xlsx",
    ExcelVersion.Version2016
)

# Release resources
workbook.Dispose()

Add Column Sparklines

Column sparklines are useful when comparing the relative size of individual values is more important than showing a continuous trend.

Change this line:

sparkline_group.SparklineType = SparklineType.Line

to:

sparkline_group.SparklineType = SparklineType.Column

The rest of the code can remain unchanged.

Column sparklines work well for data such as:

Monthly order volumes
Inventory levels
Department expenses
Completion counts by stage

Add Win/Loss Sparklines

A win/loss sparkline is useful when the data represents positive and negative outcomes.

Set the sparkline type as follows:

sparkline_group.SparklineType = SparklineType.Stacked

For example, the following values may represent the difference between actual results and monthly targets:

performance_data = [
    12, -5, 8, 15, -3, -10,
    6, 9, -4, 11, 7, -2
]

In a win/loss sparkline, positive and negative values are shown in opposite directions. The chart emphasizes whether a result is above or below zero rather than the exact difference between values.

Typical use cases include:

Monthly profit and loss
Results above or below a target
Month-over-month growth and decline
Win and loss records

Add Sparklines to an Existing Excel Workbook

When the source data already exists in an Excel file, there is no need to recreate the worksheet. Load the workbook, locate the data range, and add the sparklines directly.

from spire.xls import *
from spire.xls.common import *

workbook = Workbook()

# Load an existing Excel workbook
workbook.LoadFromFile("monthly_sales.xlsx")

# Get the first worksheet
sheet = workbook.Worksheets[0]

# Create a line sparkline group
sparkline_group = sheet.SparklineGroups.AddGroup()
sparkline_group.SparklineType = SparklineType.Line
sparkline_group.SparklineColor = Color.get_DarkBlue()

# Create a sparkline collection
sparklines = sparkline_group.Add()

# Add sparklines
for row in range(2, 6):
    sparklines.Add(
        sheet.Range[f"B{row}:M{row}"],
        sheet.Range[f"N{row}"]
    )

# Save the result as a new file
workbook.SaveToFile(
    "monthly_sales_with_sparklines.xlsx",
    ExcelVersion.Version2016
)

workbook.Dispose()

Saving the result as a new file is generally safer than overwriting the original workbook.

Practical Considerations

Match Each Data Range to the Correct Destination Cell

Every sparkline uses two ranges:

A source data range, such as B2:M2
A destination cell, such as N2

If the row references do not match, the sparkline may display data for a different product or record.

Sparklines in the Same Group Share Their Type and Formatting

All sparklines in one group generally use the same chart type and formatting.

If one section requires line sparklines and another section requires column sparklines, create separate sparkline groups.

Win/Loss Sparklines Focus on Positive and Negative Results

Win/loss sparklines do not emphasize the exact size of each value. They are designed to show whether values are positive or negative.

Use line or column sparklines when the magnitude and progression of the data matter.

Sparklines Do Not Replace Full Excel Charts

Sparklines are useful for compact trend visualization, but they usually do not include:

Axis titles
Data labels
Legends
Detailed scales

A standard Excel chart is more appropriate when a report needs precise values, several data series, or more complex comparisons.

Conclusion

Excel sparklines provide a compact way to display trends without taking up large areas of a worksheet.

With Python, you can:

Create an Excel workbook containing business data
Add sparklines to multiple rows
Create line, column, and win/loss sparklines
Configure sparkline colors
Add a trend column to an existing Excel report

For monthly sales, inventory, cost, and operational data, sparklines make it easier to identify growth, decline, and unusual changes while preserving the original table layout.

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.