DEV Community: Dheeraj Malik

How to Read, Update, and Clear PDF Document Properties in Java

Dheeraj Malik — Thu, 22 Oct 2026 09:33:27 +0000

PDF files can contain information beyond what's displayed on their pages, including the document title, author, subject, keywords, and creation date. These properties can be viewed in PDF readers and are sometimes used to organize or identify documents.

You may need to check these details, correct outdated information, or clear certain properties before sharing a PDF.

This article covers how to read, update, and clear common PDF document properties using Java.

1. Add the Maven Dependency

First, add a PDF processing library to your Java project. If you're using Maven, include the following repository and dependency in your pom.xml file:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.10.0</version>
    </dependency>
</dependencies>

The examples below use an existing PDF named report.pdf. Each example is a standalone Java program.

2. Read PDF Document Properties in Java

To retrieve information such as the document title, author, or keywords, use PdfDocument.getDocumentInformation().

This method returns a PdfDocumentInformation object, which provides access to the PDF's standard document properties.

Here's a complete example:

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfDocumentInformation;

public class ReadPDFProperties {

    public static void main(String[] args) {

        PdfDocument pdf = new PdfDocument();

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

            // Access the document properties
            PdfDocumentInformation info =
                    pdf.getDocumentInformation();

            // Read and display the properties
            System.out.println("Title: " + info.getTitle());
            System.out.println("Author: " + info.getAuthor());
            System.out.println("Subject: " + info.getSubject());
            System.out.println("Keywords: " + info.getKeywords());

            System.out.println("Creator: " + info.getCreator());
            System.out.println("Producer: " + info.getProducer());

            System.out.println("Creation Date: "
                    + info.getCreationDate());
            System.out.println("Modification Date: "
                    + info.getModificationDate());

        } finally {
            // Release document resources
            pdf.close();
        }
    }
}

The program prints the available properties to the console.

Most fields are straightforward, but two are worth distinguishing:

Creator: The application used to create the original document.
Producer: The software or component that generated the PDF.

For example, if a document was written in Microsoft Word and later exported to PDF, the creator and producer information may refer to different applications.

Also, not every PDF contains all these properties. Some values may be empty or null, depending on how the file was created.

3. Update PDF Document Properties in Java

Document properties may need to be updated when a report is finalized or its descriptive information changes.

Suppose a project report has an outdated title and author. You can update these fields directly without recreating the document's page content.

The PdfDocumentInformation class provides methods such as setTitle(), setAuthor(), setSubject(), and setKeywords() for this purpose.

The following example updates several properties and sets the modification date to the current time.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfDocumentInformation;

import java.util.Date;

public class UpdatePDFProperties {

    public static void main(String[] args) {

        PdfDocument pdf = new PdfDocument();

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

            // Access the document properties
            PdfDocumentInformation info =
                    pdf.getDocumentInformation();

            // Update the document title
            info.setTitle("Q3 2026 Project Report");

            // Update the author
            info.setAuthor("Project Management Team");

            // Update the subject
            info.setSubject(
                    "Quarterly Project Progress and Risk Analysis");

            // Update the keywords
            info.setKeywords(
                    "project report, progress, risk analysis");

            // Set the modification date
            info.setModificationDate(new Date());

            // Save the updated PDF
            pdf.saveToFile("report-updated.pdf");

            System.out.println("PDF properties updated.");

        } finally {
            // Release document resources
            pdf.close();
        }
    }
}

The program creates report-updated.pdf with the new property values.

Here's what the main methods change:

Method	Property
`setTitle()`	Document title
`setAuthor()`	Author
`setSubject()`	Subject or description
`setKeywords()`	Keywords
`setModificationDate()`	Modification date

Using new Date() sets the modification date to the current system time.

One important distinction: changing a PDF's document properties does not change the text displayed on its pages.

For example, setting the title to "Q3 2026 Project Report" won't automatically update a heading on the first page. The document's metadata and visible page content are stored separately.

4. Clear Common PDF Document Properties in Java

Sometimes a PDF contains document properties that are no longer relevant, such as an old author name, internal project keywords, or information about the original editing application.

If you want to clear these fields, you can set their values to empty strings.

The following example clears the title, author, subject, keywords, and creator fields.

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfDocumentInformation;

public class ClearPDFProperties {

    public static void main(String[] args) {

        PdfDocument pdf = new PdfDocument();

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

            // Access the document properties
            PdfDocumentInformation info =
                    pdf.getDocumentInformation();

            // Clear selected document properties
            info.setTitle("");
            info.setAuthor("");
            info.setSubject("");
            info.setKeywords("");
            info.setCreator("");

            // Save the modified PDF
            pdf.saveToFile("report-cleared-properties.pdf");

            System.out.println(
                    "Selected PDF properties have been cleared.");

        } finally {
            // Release document resources
            pdf.close();
        }
    }
}

The resulting file is saved as report-cleared-properties.pdf.

Here, the property setters assign empty strings to the selected fields. This clears their values without changing the PDF's visible page content.

However, clearing these fields is not the same as removing all metadata from a PDF.

PDFs may also contain XMP metadata, custom properties, and other embedded information. Those are not necessarily affected by the setters used above.

In addition, the PDF processing software may write or update certain properties when saving the document.

If metadata removal is required for privacy or compliance purposes, these operations alone are not sufficient. You'll need to inspect the output file and check for other metadata and potentially sensitive content.

5. Considerations

Standard Document Properties vs. XMP Metadata

PDF files can store common properties, such as titles and authors, in a document information dictionary. They may also contain XMP metadata, which stores structured information about the document.

These two sources can contain overlapping information, but updating one doesn't necessarily mean the other will be updated.

The examples in this article focus on common properties accessed through PdfDocumentInformation. If you need to inspect or change XMP metadata, that requires additional handling.

PDF Dates Are Different from File System Dates

The creation and modification dates stored inside a PDF are not the same as the timestamps managed by your operating system.

For example, copying an older PDF to another folder may change its file system timestamps without changing the creation date recorded in its internal document properties.

When using dates for document tracking or archiving, make sure you're reading the appropriate source.

Save and Check the Output File

Reading document properties doesn't modify the PDF, but updating or clearing them requires saving the document.

All examples that make changes save the result to a new file, leaving the original unchanged.

After saving, it's worth reopening the output PDF and checking its properties. Some fields may be added or updated during the save process, so the final file should be inspected rather than assuming every change was preserved exactly as requested.

How to Add, Edit, and Remove Hyperlinks in PowerPoint Using Java

Dheeraj Malik — Thu, 22 Oct 2026 09:04:20 +0000

Hyperlinks in PowerPoint can point to websites, external resources, or other slides in the same presentation. For example, you might link a reference document from a project report or create a clickable table of contents for navigating between sections.

Java lets you add hyperlinks to text and images, create links between slides, and update or remove existing links.

This article walks through each of these operations with complete Java examples.

1. Add the Maven Dependency

First, add a PowerPoint processing library to your Java project.

If you're using Maven, include the following repository and dependency in your pom.xml file:

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

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

The examples below work with PPTX files. Each program saves its result to a separate file, so you can test the operations independently.

2. Add a Hyperlink to Text in PowerPoint

To make a piece of text clickable, you can assign a hyperlink to a PortionEx object, which represents a text range within a paragraph.

The following example creates a slide containing the text "View Project Resources" and links it to a web page.

import com.spire.presentation.*;
import com.spire.presentation.drawing.FillFormatType;

import java.awt.geom.Rectangle2D;

public class AddTextHyperlink {

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

        Presentation presentation = new Presentation();

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

            // Add a text shape
            Rectangle2D.Double rect =
                    new Rectangle2D.Double(60, 100, 400, 100);

            IAutoShape shape = slide.getShapes()
                    .appendShape(ShapeType.RECTANGLE, rect);

            // Remove the shape fill and border
            shape.getFill().setFillType(FillFormatType.NONE);
            shape.getLine().setWidth(0);
            shape.getTextFrame().getParagraphs().clear();

            // Create a paragraph and text range
            ParagraphEx paragraph = new ParagraphEx();
            PortionEx text = new PortionEx();

            text.setText("View Project Resources");
            text.setFontHeight(22);

            // Set the hyperlink URL
            text.getClickAction().setAddress(
                    "https://www.example.com/");

            // Add the text to the shape
            paragraph.getTextRanges().append(text);

            shape.getTextFrame()
                    .getParagraphs().append(paragraph);

            // Save the presentation
            presentation.saveToFile(
                    "text-hyperlink.pptx",
                    FileFormat.PPTX_2013);

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

The key statement is:

text.getClickAction().setAddress("https://www.example.com/");

getClickAction() accesses the text's click action, while setAddress() assigns the destination URL.

The generated text-hyperlink.pptx contains the linked text. When you click it in Slide Show mode, PowerPoint opens the specified web page.

The URL in this example is a placeholder. Replace it with the actual destination when using the code.

3. Add a Hyperlink to an Image

Images can also act as hyperlinks. For example, a slide might contain a website logo or a document thumbnail that opens a related page when clicked.

Unlike text hyperlinks, which are associated with text ranges, image hyperlinks are attached to the image shape itself.

The following example inserts an image and assigns it a web address.

import com.spire.presentation.*;
import com.spire.presentation.drawing.FillFormatType;

import java.awt.geom.Rectangle2D;

public class AddImageHyperlink {

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

        Presentation presentation = new Presentation();

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

            // Define the image position and size
            Rectangle2D.Double rect =
                    new Rectangle2D.Double(80, 100, 240, 120);

            // Insert an image
            IEmbedImage image = slide.getShapes()
                    .appendEmbedImage(
                            ShapeType.RECTANGLE,
                            "logo.png",
                            rect);

            // Remove the image border
            image.getLine().setFillType(FillFormatType.NONE);

            // Create a hyperlink
            ClickHyperlink hyperlink =
                    new ClickHyperlink(
                            "https://www.example.com/");

            // Assign the hyperlink to the image
            image.setClick(hyperlink);

            // Save the presentation
            presentation.saveToFile(
                    "image-hyperlink.pptx",
                    FileFormat.PPTX_2013);

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

Here, appendEmbedImage() inserts logo.png into the slide, and setClick() assigns a ClickHyperlink object to the image.

The resulting image is clickable during the presentation.

Make sure logo.png exists in your application's working directory, or replace it with an absolute file path.

4. Link to Another Slide in the Same Presentation

Hyperlinks don't have to point to external websites. They can also navigate between slides within the same PowerPoint file.

This is useful for presentations with a table of contents or sections that users may want to visit in a different order.

To create an internal hyperlink, use ClickHyperlink(ISlide) to specify the destination slide.

The following example creates a two-slide presentation and adds a link on the first slide that opens the second.

import com.spire.presentation.*;
import com.spire.presentation.drawing.FillFormatType;

import java.awt.geom.Rectangle2D;

public class AddSlideHyperlink {

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

        Presentation presentation = new Presentation();

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

            // Add a second slide
            ISlide secondSlide =
                    presentation.getSlides().append();

            // Add content to the second slide
            Rectangle2D.Double targetRect =
                    new Rectangle2D.Double(60, 100, 450, 100);

            IAutoShape targetShape = secondSlide.getShapes()
                    .appendShape(ShapeType.RECTANGLE, targetRect);

            targetShape.getFill()
                    .setFillType(FillFormatType.NONE);
            targetShape.getLine().setWidth(0);

            targetShape.appendTextFrame("Project Details");

            // Add a text shape to the first slide
            Rectangle2D.Double linkRect =
                    new Rectangle2D.Double(60, 100, 450, 100);

            IAutoShape linkShape = firstSlide.getShapes()
                    .appendShape(ShapeType.RECTANGLE, linkRect);

            linkShape.getFill()
                    .setFillType(FillFormatType.NONE);
            linkShape.getLine().setWidth(0);
            linkShape.getTextFrame().getParagraphs().clear();

            // Create the clickable text
            ParagraphEx paragraph = new ParagraphEx();
            PortionEx text = new PortionEx();

            text.setText("Go to Project Details");
            text.setFontHeight(22);

            // Link to the second slide
            ClickHyperlink hyperlink =
                    new ClickHyperlink(secondSlide);

            text.setClickAction(hyperlink);

            paragraph.getTextRanges().append(text);

            linkShape.getTextFrame()
                    .getParagraphs().append(paragraph);

            // Save the presentation
            presentation.saveToFile(
                    "slide-hyperlink.pptx",
                    FileFormat.PPTX_2013);

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

The important part is:

ClickHyperlink hyperlink =
        new ClickHyperlink(secondSlide);

text.setClickAction(hyperlink);

Instead of passing a URL, we pass the destination slide as an ISlide object.

When the presentation is in Slide Show mode, clicking "Go to Project Details" navigates directly to the second slide.

You can use the same approach with an existing presentation. Retrieve the destination slide using presentation.getSlides().get(index) and assign it to a hyperlink.

Remember that slide indexes start at zero, so get(0) refers to the first slide and get(2) refers to the third.

5. Edit an Existing Hyperlink in PowerPoint

Links sometimes need to be updated when a website address changes or a referenced resource moves.

Rather than recreating the linked text, you can retrieve its text range and update the display text or destination URL.

The following example opens text-hyperlink.pptx, created in Section 2, and changes both the displayed text and the web address.

import com.spire.presentation.*;

public class EditPptHyperlink {

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

        Presentation presentation = new Presentation();

        try {
            // Load the presentation
            presentation.loadFromFile(
                    "text-hyperlink.pptx");

            // Get the shape containing the hyperlink
            IAutoShape shape = (IAutoShape) presentation
                    .getSlides().get(0)
                    .getShapes().get(0);

            // Update the hyperlink display text
            shape.getTextFrame()
                    .getTextRange()
                    .setText("View Updated Project Resources");

            // Update the hyperlink URL
            shape.getTextFrame()
                    .getTextRange()
                    .getClickAction()
                    .setAddress(
                            "https://www.wikipedia.org/");

            // Save the updated presentation
            presentation.saveToFile(
                    "edited-hyperlink.pptx",
                    FileFormat.PPTX_2013);

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

The code uses setText() to change the displayed text and getClickAction().setAddress() to update the link destination.

The resulting edited-hyperlink.pptx contains the updated hyperlink.

One thing to watch for: This example accesses the first shape on the first slide because the structure of the input file is known.

In an existing presentation, a text box may contain several text ranges, each with different formatting or hyperlinks. In that case, locate the specific linked text range before editing it rather than assuming the first shape or entire text frame contains the intended link.

6. Remove a Hyperlink Without Deleting the Text

If a hyperlink is no longer needed, you can remove its click action while keeping the text.

For text hyperlinks, this can be done using setClickAction(null).

The following example removes the hyperlink from text-hyperlink.pptx, leaving the displayed text unchanged.

import com.spire.presentation.*;

public class RemovePptHyperlink {

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

        Presentation presentation = new Presentation();

        try {
            // Load the presentation
            presentation.loadFromFile(
                    "text-hyperlink.pptx");

            // Get the shape containing the hyperlink
            IAutoShape shape = (IAutoShape) presentation
                    .getSlides().get(0)
                    .getShapes().get(0);

            // Remove the hyperlink
            shape.getTextFrame()
                    .getTextRange()
                    .setClickAction(null);

            // Save the presentation
            presentation.saveToFile(
                    "removed-hyperlink.pptx",
                    FileFormat.PPTX_2013);

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

The key statement is:

shape.getTextFrame().getTextRange().setClickAction(null);

Setting the click action to null removes the hyperlink from the text range without deleting the text itself.

The text may still retain its previous formatting, such as an underline or a hyperlink color. If you want it to look like ordinary text again, you may also need to adjust its formatting.

As with the previous example, this code assumes that the text shape and hyperlink are already known. For more complex presentations, identify the appropriate text range before removing its click action.

7. Things to Keep in Mind

Test Hyperlinks in Slide Show Mode

In PowerPoint's editing view, clicking text or an image usually selects the object rather than immediately following its hyperlink.

To check whether a hyperlink works, open the presentation in Slide Show mode and click the linked element.

External Links Depend on Their Destinations

A hyperlink may be stored correctly in the PPTX file even if its target website is unavailable or its address has changed.

Links to local files can also stop working when a presentation is moved to another computer or the referenced files are relocated.

Text and Shape Hyperlinks Are Different

Text hyperlinks are associated with text ranges, while image and shape hyperlinks are typically associated with the shape itself.

This distinction matters when editing or removing links. You need to identify whether the link belongs to a text range or the containing shape before changing its click action.

Be Careful When Working with Existing Slides

The examples for editing and removing hyperlinks access a shape by its index because they use a presentation with a known structure.

For real-world presentations containing multiple text boxes, images, charts, or grouped shapes, don't assume the target hyperlink is always in the first shape. Locate the relevant object and text range before making changes.

How to Extract Text from PowerPoint in Java: All Slides, Specific Slides, and Tables

Dheeraj Malik — Fri, 16 Oct 2026 05:54:08 +0000

PowerPoint presentations often contain text that needs to be reused in reports, documentation, or other files. Instead of copying it slide by slide, you can use Java to extract the text and save it to a separate file.

This article covers three scenarios: extracting text from an entire presentation, reading text from a specific slide, and extracting text from PowerPoint tables.

1. Add the Maven Dependency

First, add a PowerPoint processing library to your Java project. If you're using Maven, include the following repository and dependency in your pom.xml file:

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

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

For the examples below, we'll use a presentation named report.pptx containing slide titles, body text, project updates, and tables.

Each example is a standalone Java program that saves the extracted content to a UTF-8 text file.

2. Extract Text from All PowerPoint Slides

To extract text from an entire presentation, you can loop through its slides and examine the shapes on each one.

In PowerPoint, titles, text boxes, and many shapes containing text can be accessed through the IAutoShape interface. Each text frame contains paragraphs, and their text can be retrieved using ParagraphEx.getText().

Here's the complete code:

import com.spire.presentation.*;

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

public class ExtractAllPPTText {

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

        Presentation presentation = new Presentation();

        try {
            // Load the PowerPoint presentation
            presentation.loadFromFile("report.pptx");

            StringBuilder result = new StringBuilder();

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

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

                // Add the slide number
                result.append("Slide ")
                      .append(i + 1)
                      .append(System.lineSeparator());

                // Loop through shapes on the slide
                for (Object shape : slide.getShapes()) {

                    if (shape instanceof IAutoShape) {

                        IAutoShape autoShape = (IAutoShape) shape;

                        // Read text from each paragraph
                        for (Object item :
                                autoShape.getTextFrame()
                                         .getParagraphs()) {

                            ParagraphEx paragraph =
                                    (ParagraphEx) item;

                            String text = paragraph.getText();

                            if (text != null &&
                                    !text.trim().isEmpty()) {
                                result.append(text)
                                      .append(System.lineSeparator());
                            }
                        }
                    }
                }

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

            // Save the extracted text as UTF-8
            Files.write(
                    Paths.get("ppt-all-text.txt"),
                    result.toString()
                          .getBytes(StandardCharsets.UTF_8));

            System.out.println("Text extraction completed.");

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

The program creates ppt-all-text.txt, with the extracted text grouped by slide number.

The main methods are:

getSlides() retrieves the slides in the presentation.
getShapes() provides access to the shapes on each slide.
getTextFrame().getParagraphs() retrieves the paragraphs inside a text-containing shape.
ParagraphEx.getText() returns the text of each paragraph.

The code skips empty paragraphs and adds a slide number before each group of text.

One limitation is worth noting: this example extracts text from IAutoShape objects, not every type of content in a PowerPoint file. Text in tables, speaker notes, images, and some other objects requires separate handling.

Also, the extracted text follows the order of shapes in the slide's collection, which may differ from their visual reading order.

3. Extract Text from a Specific PowerPoint Slide

Sometimes you only need the text from one slide. For example, you might want to extract a project summary from slide 3 without processing the rest of the presentation.

You can access a particular slide using presentation.getSlides().get(index) and then read the text from its shapes.

The following example extracts text from the third slide:

import com.spire.presentation.*;

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

public class ExtractSingleSlideText {

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

        Presentation presentation = new Presentation();

        try {
            // Load the PowerPoint presentation
            presentation.loadFromFile("report.pptx");

            // Specify the slide number
            int slideNumber = 3;

            // Check whether the slide exists
            if (slideNumber < 1 ||
                    slideNumber > presentation.getSlides().getCount()) {
                throw new IllegalArgumentException(
                        "The specified slide does not exist.");
            }

            // Get the specified slide
            ISlide slide = presentation.getSlides()
                    .get(slideNumber - 1);

            StringBuilder result = new StringBuilder();

            // Loop through shapes on the slide
            for (Object shape : slide.getShapes()) {

                if (shape instanceof IAutoShape) {

                    IAutoShape autoShape = (IAutoShape) shape;

                    // Extract text from each paragraph
                    for (Object item :
                            autoShape.getTextFrame()
                                     .getParagraphs()) {

                        ParagraphEx paragraph =
                                (ParagraphEx) item;

                        String text = paragraph.getText();

                        if (text != null &&
                                !text.trim().isEmpty()) {
                            result.append(text)
                                  .append(System.lineSeparator());
                        }
                    }
                }
            }

            // Save the extracted text
            Files.write(
                    Paths.get("slide-3-text.txt"),
                    result.toString()
                          .getBytes(StandardCharsets.UTF_8));

            System.out.println("Slide 3 text extracted.");

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

The program saves the text from the third slide to slide-3-text.txt.

Keep in mind that slide indexes start at zero:

get(0) accesses slide 1.
get(1) accesses slide 2.
get(2) accesses slide 3.

That's why the code uses slideNumber - 1 to convert the slide number into a collection index.

It also checks whether the requested slide exists before trying to access it.

If you need text from several selected slides, you can use an array of slide numbers and process only those slides.

4. Extract Text from Tables in PowerPoint

PowerPoint presentations may also contain tables, such as project schedules, budget summaries, or comparison data.

Unlike ordinary text boxes, tables store their text in individual cells. To read that content, you can locate ITable objects, loop through their rows and columns, and extract the text from each cell.

The following example searches all slides for tables and saves their contents as tab-separated text.

import com.spire.presentation.*;

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

public class ExtractPPTTableText {

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

        Presentation presentation = new Presentation();

        try {
            // Load the PowerPoint presentation
            presentation.loadFromFile("report.pptx");

            StringBuilder result = new StringBuilder();

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

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

                // Find tables on the slide
                for (Object shape : slide.getShapes()) {

                    if (shape instanceof ITable) {

                        ITable table = (ITable) shape;

                        result.append("Table on Slide ")
                              .append(i + 1)
                              .append(System.lineSeparator());

                        // Get the number of rows and columns
                        int rowCount =
                                table.getTableRows().getCount();

                        int columnCount =
                                table.getColumnsList().getCount();

                        // Loop through table cells
                        for (int row = 0; row < rowCount; row++) {

                            for (int col = 0;
                                 col < columnCount;
                                 col++) {

                                // Read text from the cell
                                String text = table.get(col, row)
                                        .getTextFrame()
                                        .getText();

                                if (text != null) {
                                    // Replace line breaks and tabs
                                    text = text.replace("\r", " ")
                                               .replace("\n", " ")
                                               .replace("\t", " ");

                                    result.append(text);
                                }

                                // Separate columns with tabs
                                if (col < columnCount - 1) {
                                    result.append("\t");
                                }
                            }

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

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

            // Save the extracted table text
            Files.write(
                    Paths.get("ppt-table-text.txt"),
                    result.toString()
                          .getBytes(StandardCharsets.UTF_8));

            System.out.println("Table text extraction completed.");

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

The code uses three methods to access table content:

getTableRows().getCount() returns the number of rows.
getColumnsList().getCount() returns the number of columns.
table.get(col, row) retrieves a cell using its column and row indexes.

Notice that table.get() takes the column index first, followed by the row index. Both indexes start at zero.

Once a cell is retrieved, getTextFrame().getText() returns its text.

For example, suppose a slide contains this table:

Task	Owner	Status
Module A	Alex	Completed
Module B	Emma	In Progress

The extracted text would look approximately like this:

Table on Slide 2
Task    Owner   Status
Module A    Alex    Completed
Module B    Emma    In Progress

Columns are separated by tabs, while rows are separated by line breaks. This makes the output easier to read or import into another application.

The example also replaces line breaks and tabs inside individual cells with spaces to keep each table row on one line.

For tables with merged cells, a straightforward row-and-column loop may produce empty or repeated positions. Those cases may require additional handling based on the table structure.

5. Things to Keep in Mind

Text Inside Images Requires OCR

If a slide contains text as part of an image, such as a screenshot or scanned document, it cannot be extracted using ordinary text frame methods.

You would need optical character recognition (OCR) to identify the text in those images.

Not All PowerPoint Text Is Stored in Regular Shapes

Slide titles and text boxes can typically be accessed through IAutoShape, while table content is accessed through ITable.

Speaker notes, chart labels, text inside grouped objects, and other elements may require different handling.

If you need to extract all available text from a presentation, check which object types are present instead of assuming a single loop will capture everything.

Plain Text Does Not Preserve Formatting

Saving extracted content as TXT removes the original PowerPoint formatting, including font styles, colors, positions, and slide layouts.

If you need to preserve information such as heading levels or table structures, consider adding markers during extraction or using a structured output format instead.

Use UTF-8 for Text Files

All three examples use StandardCharsets.UTF_8 when writing the output files.

This helps preserve non-ASCII characters, including Chinese, Japanese, and other multilingual text, across different operating systems.

6. Conclusion

Extracting text from PowerPoint in Java depends on where the text is stored.

Before processing a presentation, it's worth checking whether its content consists of regular text, tables, images, or other objects. This helps you choose the appropriate extraction method and avoid missing content.

How to Add, Read, Edit, and Delete Excel Comments in Java

Dheeraj Malik — Fri, 16 Oct 2026 03:34:38 +0000

When working with Excel spreadsheets, you may need to add information that doesn't belong directly in a cell, such as the reason for a price change, an explanation of an unusual value, or a reminder to verify certain data.

Excel comments let you attach these notes to individual cells without changing their values. You can also use Java to add, read, update, or remove them programmatically.

This article covers these four operations with complete Java examples.

1. Add the Maven Dependency

To get started, add an Excel processing library to your Java project. If you're using Maven, include the following repository and dependency in your pom.xml file:

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

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.xls.free</artifactId>
        <version>16.3.1</version>
    </dependency>
</dependencies>

2. Add Comments to Excel Cells in Java

To add a comment to an Excel cell, use the CellRange.addComment() method. It returns an ExcelComment object, which you can use to set the comment text and adjust its appearance.

For the examples below, we'll use a workbook named sales.xlsx, with the following data on its first worksheet:

Product	Quantity	Unit Price	Amount
Product A	20	49	980
Product B	15	60	900

The table occupies cells A1:D3. We'll add a note explaining the price in C2 and another reminding us to verify the amount in D3:

import com.spire.xls.*;

public class AddExcelComments {

    public static void main(String[] args) {

        Workbook workbook = new Workbook();

        try {
            // Load the Excel file
            workbook.loadFromFile("sales.xlsx");

            // Get the first worksheet
            Worksheet sheet = workbook.getWorksheets().get(0);

            // Add a comment to cell C2
            ExcelComment comment1 =
                    sheet.getCellRange("C2").addComment();

            comment1.setText(
                    "The unit price was updated this month.");

            // Set the comment box size
            comment1.setWidth(220);
            comment1.setHeight(60);

            // Keep the comment box hidden by default
            comment1.setVisible(false);

            // Add a comment to cell D3
            ExcelComment comment2 =
                    sheet.getCellRange("D3").addComment();

            comment2.setText(
                    "Please verify this amount.");
            comment2.setAutoSize(true);

            // Save the modified workbook
            workbook.saveToFile(
                    "sales-with-comments.xlsx",
                    ExcelVersion.Version2016);

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

The program creates sales-with-comments.xlsx, with a comment attached to each of the two cells.

Besides setting the text, you can control how a comment appears:

setWidth() and setHeight() specify the comment box dimensions.
setAutoSize(true) adjusts the box size to fit its text.
setVisible(false) keeps the comment box from being displayed continuously.

Setting a comment's visibility to false doesn't remove it. The comment remains attached to the cell and can still be viewed in Excel.

3. Read Comments from an Excel Worksheet

You may also need to inspect comments already stored in a workbook, such as when checking notes left during a review.

The Worksheet.getComments() method provides access to the comments collection for a worksheet. You can iterate through it and retrieve each comment's text and location.

The following example reads all comments from the workbook created in the previous section:

import com.spire.xls.*;

public class ReadExcelComments {

    public static void main(String[] args) {

        Workbook workbook = new Workbook();

        try {
            // Load the Excel file
            workbook.loadFromFile(
                    "sales-with-comments.xlsx");

            // Get the first worksheet
            Worksheet sheet = workbook.getWorksheets().get(0);

            // Get the number of comments
            int count = sheet.getComments().getCount();

            System.out.println("Total comments: " + count);

            // Read each comment
            for (int i = 0; i < count; i++) {

                ExcelComment comment =
                        sheet.getComments().get(i);

                System.out.println("Comment " + (i + 1));
                System.out.println("Row: " + comment.getRow());
                System.out.println("Column: " + comment.getColumn());
                System.out.println("Text: " + comment.getText());
                System.out.println("----------------");
            }

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

The program prints the number of comments and the row, column, and text of each one.

If you already know which cell contains the comment, there's no need to loop through the entire collection. You can retrieve it directly using getComment():

ExcelComment comment =
        sheet.getCellRange("C2").getComment();

if (comment != null) {
    System.out.println(comment.getText());
}

The null check matters because not every cell has a comment. It prevents a NullPointerException when the requested cell has none.

4. Edit an Existing Excel Comment

Comments sometimes need to be updated as the information in a spreadsheet changes.

For example, suppose the unit price in C2 has now been verified. We can replace the original comment with "The current unit price has been verified."

There's no need to remove the existing comment and create a new one. Simply retrieve it with getComment() and update its text using setText().

import com.spire.xls.*;

public class EditExcelComment {

    public static void main(String[] args) {

        Workbook workbook = new Workbook();

        try {
            // Load the workbook containing comments
            workbook.loadFromFile(
                    "sales-with-comments.xlsx");

            // Get the first worksheet
            Worksheet sheet = workbook.getWorksheets().get(0);

            // Get the existing comment in C2
            ExcelComment comment =
                    sheet.getCellRange("C2").getComment();

            // Update the comment
            if (comment != null) {

                comment.setText(
                        "The current unit price has been verified.");

                // Resize the comment box to fit the text
                comment.setAutoSize(true);
            }

            // Save the updated workbook
            workbook.saveToFile(
                    "sales-edited-comments.xlsx",
                    ExcelVersion.Version2016);

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

After running the code, open sales-edited-comments.xlsx to see the updated comment in C2.

Only the comment text and its box sizing are changed. The cell's value remains the same.

You can also modify other comment properties, such as its dimensions, visibility, and text formatting, without recreating the comment.

5. Delete Comments from Excel Cells

Once a note is no longer needed, you can remove it from the worksheet.

Suppose the amount in D3 has been checked, and the reminder to verify it is no longer relevant.

Use getComment() to retrieve the comment, then call remove() to delete it.

import com.spire.xls.*;

public class DeleteExcelComment {

    public static void main(String[] args) {

        Workbook workbook = new Workbook();

        try {
            // Load the workbook containing comments
            workbook.loadFromFile(
                    "sales-with-comments.xlsx");

            // Get the first worksheet
            Worksheet sheet = workbook.getWorksheets().get(0);

            // Get the comment in cell D3
            ExcelComment comment =
                    sheet.getCellRange("D3").getComment();

            // Remove the comment if it exists
            if (comment != null) {
                comment.remove();
            }

            // Save the modified workbook
            workbook.saveToFile(
                    "sales-removed-comment.xlsx",
                    ExcelVersion.Version2016);

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

The resulting file, sales-removed-comment.xlsx, no longer contains the comment in D3. The value stored in that cell is preserved, as are the comments in other cells.

If you need to remove comments from several known cells, you can repeat the same operation for each one.

6. A Few Things to Keep in Mind

Traditional Comments vs. Threaded Comments

The examples in this article work with traditional Excel cell comments, which are called Notes in newer versions of Microsoft Excel.

These are different from modern threaded comments, which support replies and @mentions. The APIs shown here should not be assumed to work with threaded comments.

Check Whether a Comment Already Exists

Before adding a comment to a cell, consider whether it already has one.

If your goal is to update an existing note, use getComment() followed by setText() rather than creating another comment.

Save Changes to the Workbook

Adding, editing, or deleting a comment changes the workbook in memory. To write those changes to an Excel file, you must call workbook.saveToFile().

The examples save their results to new files so that the original workbook remains unchanged. If you need to overwrite an existing file, it's worth keeping a backup.

How to Merge PDF Files in Java: Entire Documents, Selected Pages, and Input Streams

Dheeraj Malik — Sat, 10 Oct 2026 10:42:47 +0000

When preparing reports or organizing project files, you may need to combine several PDFs into a single document. Sometimes you need all the pages from each file. Other times, you only want to include certain pages. If the PDF data comes from memory or a network response, working with input streams may be more convenient.

This article covers three ways to merge PDFs in Java: combining entire documents, merging selected pages from multiple PDFs, and merging PDFs using input streams.

1. Add the Maven Dependency

First, add the following repository and dependency to your Java project's pom.xml file:

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

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

For the examples below, we'll use three PDF files:

pdfs/
├── 01-cover.pdf
├── 02-report.pdf
└── 03-appendix.pdf

These files contain a cover page, the main report, and an appendix, respectively. Each example is a standalone Java program that saves the merged PDF to a separate output file.

2. Merge Multiple PDF Files into One

If you want to combine all pages from multiple PDF files, you can use the PdfDocument.mergeFiles() method.

This method accepts an array of PDF file paths and saves the merged document to a specified location.

Here's the complete Java code:

import com.spire.pdf.PdfDocument;

public class MergePDF {

    public static void main(String[] args) {

        // Specify the PDF files to merge
        String[] files = {
                "pdfs/01-cover.pdf",
                "pdfs/02-report.pdf",
                "pdfs/03-appendix.pdf"
        };

        // Specify the output file path
        String outputFile = "merged.pdf";

        // Merge the PDF files
        PdfDocument.mergeFiles(files, outputFile);

        System.out.println("PDFs merged successfully: " + outputFile);
    }
}

The main method used here is PdfDocument.mergeFiles(files, outputFile), which takes two arguments:

files: An array containing the paths of the PDF files to merge.
outputFile: The path where the merged PDF will be saved.

The files are merged in the order they appear in the array. In this example, the resulting merged.pdf contains all pages from the cover, followed by the main report and then the appendix.

To change the order, simply rearrange the file paths in the array. There's no need to modify the source PDFs.

3. Merge Selected Pages from Multiple PDF Files

Sometimes you don't need every page from each PDF. For example, you might want to combine the cover page of a report, a few pages from its main content, and the first page of an appendix.

To do this, load the source PDFs and insert the required pages into a new document using two methods:

insertPage(): Inserts a single page from a source PDF.
insertPageRange(): Inserts a continuous range of pages from a source PDF.

Suppose we want to merge the following pages:

Source PDF	Pages to include
01-cover.pdf	Page 1
02-report.pdf	Pages 2–4
03-appendix.pdf	Page 1

The resulting PDF will contain five pages in the specified order.

Here's the complete code:

import com.spire.pdf.PdfDocument;

public class MergeSelectedPDFPages {

    public static void main(String[] args) {

        // Create PDF document objects for the source files
        PdfDocument cover = new PdfDocument();
        PdfDocument report = new PdfDocument();
        PdfDocument appendix = new PdfDocument();

        // Create a new PDF document for the merged pages
        PdfDocument mergedPdf = new PdfDocument();

        try {
            // Load the source PDF files
            cover.loadFromFile("pdfs/01-cover.pdf");
            report.loadFromFile("pdfs/02-report.pdf");
            appendix.loadFromFile("pdfs/03-appendix.pdf");

            // Check whether the required pages exist
            if (cover.getPages().getCount() < 1
                    || report.getPages().getCount() < 4
                    || appendix.getPages().getCount() < 1) {
                throw new IllegalArgumentException(
                        "One or more source PDFs do not contain the required pages.");
            }

            // Insert page 1 from the cover
            mergedPdf.insertPage(cover, 0);

            // Insert pages 2 through 4 from the report
            mergedPdf.insertPageRange(report, 1, 3);

            // Insert page 1 from the appendix
            mergedPdf.insertPage(appendix, 0);

            // Save the merged PDF
            mergedPdf.saveToFile("merged-selected.pdf");

            System.out.println("Selected PDF pages merged successfully.");

        } finally {
            // Release PDF document resources
            mergedPdf.close();
            cover.close();
            report.close();
            appendix.close();
        }
    }
}

There are two important details to keep in mind when working with page indexes.

Page Indexes Start at Zero

In the code, page indexes are zero-based. This means page 1 has an index of 0, page 2 has an index of 1, and so on.

For example:

mergedPdf.insertPage(cover, 0);

This inserts the first page of the cover PDF into the merged document.

insertPageRange() Includes the End Index

The following statement:

mergedPdf.insertPageRange(report, 1, 3);

Inserts pages with indexes 1, 2, and 3 from report, corresponding to pages 2–4. Both the start and end indexes are included.

Pages are added in the order the insertion methods are called, so you can control the final page order by changing the sequence of these operations.

Page indexes must also fall within the source document's page count. The example checks the available pages before inserting them to avoid referencing pages that don't exist.

If you need several nonconsecutive pages, you can call insertPage() multiple times with different page indexes.

4. Merge PDF Files Using Input Streams

In addition to merging PDFs by file path, you can merge them using input streams.

For example, in a web application, PDF data might come from uploaded files, network responses, or byte arrays stored in memory. In these cases, you may not need to save each source PDF as a temporary file before merging.

The PdfDocument.mergeFiles() method has an overload that accepts an InputStream[] array, allowing multiple PDF streams to be merged directly.

The following example uses FileInputStream to demonstrate this approach:

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

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class MergePDFByStream {

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

        // Open input streams for the PDF files
        try (InputStream stream1 = new FileInputStream(
                    "pdfs/01-cover.pdf");
             InputStream stream2 = new FileInputStream(
                    "pdfs/02-report.pdf");
             InputStream stream3 = new FileInputStream(
                    "pdfs/03-appendix.pdf")) {

            // Store the input streams in an array
            InputStream[] streams = {
                    stream1,
                    stream2,
                    stream3
            };

            // Merge the PDF streams
            PdfDocumentBase mergedPdf =
                    PdfDocument.mergeFiles(streams);

            try {
                // Save the merged PDF
                mergedPdf.save(
                        "merged-stream.pdf",
                        FileFormat.PDF);

                System.out.println("PDF streams merged successfully.");

            } finally {
                // Release the merged document resources
                mergedPdf.close();
            }
        }
    }
}

Unlike the first example, this approach uses input streams rather than file paths.

The FileInputStream objects provide access to the source PDF data. These streams are placed in an InputStream[] array and passed to:

PdfDocument.mergeFiles(streams);

The method returns a PdfDocumentBase object representing the merged document. We then use its save() method to write the result to merged-stream.pdf.

The example uses Java's try-with-resources statement to manage the input streams. They are automatically closed when the block exits, including when an exception occurs. The merged PDF document is also closed in the finally block.

One distinction is worth noting: merging PDFs through input streams doesn't necessarily mean the entire operation takes place in memory, nor does it prevent you from saving the result to disk.

In this example, the input streams read local files, and the merged PDF is saved to disk.

If the PDF data is already available as byte arrays, you can use ByteArrayInputStream instead of FileInputStream to avoid writing the source data to temporary files.

5. Things to Consider When Merging PDFs

1. Page Order Depends on the Input Order

When merging entire PDFs or input streams, the source documents are processed in the order they appear in the input array.

When merging selected pages, the final order depends on the sequence of insertPage() and insertPageRange() calls.

2. Pages May Have Different Sizes

If your source PDFs contain pages of different sizes, such as A4 and A3, the merged document may retain those differences.

Merging PDFs does not automatically resize or reformat their pages. If you need a consistent page size throughout the document, you'll have to handle that separately.

3. Password-Protected PDFs Require the Correct Password

If a source PDF is protected by an opening password, a standard merge operation may fail because the file cannot be accessed directly.

If you know the password, you can load the document using loadFromFile(filePath, password) and then merge the required pages into a new PDF.

Find and Highlight Text in Word Documents Using Java

Dheeraj Malik — Fri, 09 Oct 2026 09:57:07 +0000

When reviewing Word documents, you may need to highlight specific words or phrases. For example, you might want to mark every occurrence of "risk" in a report, or highlight phrases such as "risk assessment" and "risk analysis".

Java can handle both exact text searches and pattern-based searches. This article shows how to highlight the first match or all matches using either strings or regular expressions.

1. Install a Word Document Processing Library

Add the following repository and dependency to your Maven project's pom.xml file:

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

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

For the examples below, prepare a Word document named input.docx with the following content:

We identified a potential risk before the release.

The audit covers risk assessment and risk-analysis.

A risk review is scheduled for next week.

Another Risk Assessment will happen after launch.

Each example works independently and saves the modified document to a separate file.

2. Highlight the First Occurrence of a Word

To highlight only the first occurrence of a word, use Document.findString(). This method returns a TextSelection representing the first match.

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

import java.awt.Color;

public class HighlightFirstOccurrence {

    public static void main(String[] args) {

        Document document = new Document();

        try {
            // Load the Word document
            document.loadFromFile("input.docx");

            // Find the first occurrence of "risk"
            TextSelection selection =
                    document.findString("risk", false, false);

            // Highlight the matching text
            if (selection != null) {
                selection.getAsOneRange()
                        .getCharacterFormat()
                        .setHighlightColor(Color.YELLOW);
            }

            // Save the modified document
            document.saveToFile(
                    "HighlightFirst.docx",
                    FileFormat.Docx_2013);

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

The two Boolean arguments in findString() control case sensitivity and whole-word matching:

caseSensitive: When false, both "risk" and "Risk" can match.
wholeWord: When false, the search can also match text within longer words.

Here, both are set to false.

The code uses getAsOneRange() to access the matched text and setHighlightColor() to apply yellow highlighting.

For the sample document, only "risk" in the first sentence is highlighted. The null check prevents an error if no match is found.

3. Highlight All Occurrences of a Word

To highlight every occurrence of a word, use Document.findAllString() instead.

Unlike findString(), which returns a single match, this method returns a TextSelection[] array containing all matches.

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

import java.awt.Color;

public class HighlightAllOccurrences {

    public static void main(String[] args) {

        Document document = new Document();

        try {
            // Load the Word document
            document.loadFromFile("input.docx");

            // Find all occurrences of "risk"
            TextSelection[] selections =
                    document.findAllString(
                            "risk", false, false);

            // Highlight all matching text
            if (selections != null) {
                for (TextSelection selection : selections) {
                    selection.getAsOneRange()
                            .getCharacterFormat()
                            .setHighlightColor(Color.YELLOW);
                }
            }

            // Save the modified document
            document.saveToFile(
                    "HighlightAll.docx",
                    FileFormat.Docx_2013);

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

The code loops through the returned selections and applies yellow highlighting to each one.

In the sample document, "risk" appears five times, including the capitalized "Risk". All five occurrences are highlighted because case-sensitive matching is disabled.

Only the matched text is highlighted, not the entire paragraph.

4. Highlight Text Using Regular Expressions

Exact string searches work when the target text is known. Regular expressions are useful when the text follows a pattern but may contain variations.

For example, a document may contain:

risk assessment
risk-analysis
risk review
Risk Assessment

These phrases can be matched using one regular expression:

Pattern pattern = Pattern.compile(
        "(?i)\\brisk[\\s-]+"
        + "(?:assessment|analysis|review)\\b");

The pattern uses:

(?i) for case-insensitive matching.
\\b for word boundaries.
[\\s-]+ for one or more whitespace characters or hyphens.
(?:assessment|analysis|review) for the allowed terms.

The backslashes are doubled because the pattern is written as a Java string.

4.1 Highlight the First Regex Match

Use Document.findPattern() to find the first text matching a regular expression.

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

import java.awt.Color;
import java.util.regex.Pattern;

public class HighlightFirstPattern {

    public static void main(String[] args) {

        Document document = new Document();

        try {
            // Load the Word document
            document.loadFromFile("input.docx");

            // Define the regex pattern
            Pattern pattern = Pattern.compile(
                    "(?i)\\brisk[\\s-]+"
                    + "(?:assessment|analysis|review)\\b");

            // Find the first matching phrase
            TextSelection selection =
                    document.findPattern(pattern);

            // Highlight the matching phrase
            if (selection != null) {
                selection.getAsOneRange()
                        .getCharacterFormat()
                        .setHighlightColor(Color.YELLOW);
            }

            // Save the modified document
            document.saveToFile(
                    "HighlightFirstPattern.docx",
                    FileFormat.Docx_2013);

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

For the sample document, the first matching phrase is "risk assessment" in the second paragraph. Only this phrase is highlighted.

The findPattern() method accepts a java.util.regex.Pattern object and returns a TextSelection for the first match.

4.2 Highlight All Regex Matches

To highlight every phrase that matches the pattern, use Document.findAllPattern().

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

import java.awt.Color;
import java.util.regex.Pattern;

public class HighlightAllPatterns {

    public static void main(String[] args) {

        Document document = new Document();

        try {
            // Load the Word document
            document.loadFromFile("input.docx");

            // Define the regex pattern
            Pattern pattern = Pattern.compile(
                    "(?i)\\brisk[\\s-]+"
                    + "(?:assessment|analysis|review)\\b");

            // Find all matching phrases
            TextSelection[] selections =
                    document.findAllPattern(pattern);

            // Highlight every matching phrase
            if (selections != null) {
                for (TextSelection selection : selections) {
                    selection.getAsOneRange()
                            .getCharacterFormat()
                            .setHighlightColor(Color.YELLOW);
                }
            }

            // Save the modified document
            document.saveToFile(
                    "HighlightAllPatterns.docx",
                    FileFormat.Docx_2013);

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

The method returns a TextSelection[] array, allowing each match to be highlighted.

For the sample document, the expected matches are "risk assessment", "risk-analysis", "risk review", and "Risk Assessment" — four phrases in total.

The entire matching phrase is highlighted rather than just the word "risk".

You can also use alternation to search for unrelated terms. For example, risk|delay|failure matches any of the three words.

5. Things to Keep in Mind

Text formatting and document structure

Word documents may contain text split across multiple runs, paragraphs, or other elements. Regular expressions that span these boundaries may not behave as expected. Test complex documents separately, particularly when searching across differently formatted text.

Highlight colors

The examples use Color.YELLOW, but you can choose another color, such as Color.GREEN.

Highlighting changes the background behind the matched characters. It does not change their font color.

File paths and output

The examples use relative file paths, so input.docx must be accessible from the program's working directory. You can use an absolute path if needed.

Each example saves a new DOCX file, leaving the original unchanged.

How to Create Pivot Tables in Excel with Java

Dheeraj Malik — Thu, 24 Sep 2026 09:33:40 +0000

When working with Excel data, raw information is usually stored as detailed records. For example, a sales worksheet may contain fields such as date, region, product, quantity, and sales amount.

As the amount of data grows, analyzing the original table directly becomes less convenient. Excel Pivot Tables provide a simple way to summarize and analyze data from different perspectives, such as:

Calculating sales amounts by region;
Summarizing data by product category;
Comparing values across different dimensions.

If you need to generate analysis reports automatically in a Java application, you can create Pivot Tables programmatically instead of manually opening Excel and configuring them each time.

This article explains how to create Excel Pivot Tables with Java and configure fields for data summarization.

Preparing the Environment

Create a Java project and add the Excel processing dependency through Maven.

Add the following 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.xls</artifactId>
        <version>latest-version</version>
    </dependency>
</dependencies>

Then import the required classes:

import com.spire.xls.*;

Prepare Excel Data

Before creating a Pivot Table, prepare the data source.

For example, a sales worksheet contains the following data:

Date	Region	Product	Sales Amount
2026-01-01	East	Phone	5000
2026-01-02	South	Laptop	8000
2026-01-03	East	Tablet	3000
2026-01-04	North	Phone	6000

In this worksheet:

The first row contains field names;
The remaining rows contain data records;
The range A1:D5 will be used as the Pivot Table data source.

The following example loads the Excel file and creates a Pivot Table based on the specified data range.

Create an Excel Pivot Table

Creating a Pivot Table usually involves the following steps:

Load the Excel file;
Get the data source range;
Create a PivotCache;
Add a PivotTable;
Apply formatting;
Save the result file.

The complete example is shown below:

import com.spire.xls.*;

public class CreatePivotTable {

    public static void main(String[] args) {

        // Create a Workbook object
        Workbook workbook = new Workbook();

        // Load the Excel file containing source data
        workbook.loadFromFile("SalesData.xlsx");

        // Get the first worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        // Get the data source range
        CellRange dataRange = sheet.getCellRange("A1:D5");

        // Create a Pivot Cache from the data range
        PivotCache cache = workbook.getPivotCaches().add(dataRange);

        // Create a Pivot Table at the specified location
        PivotTable pivotTable = sheet.getPivotTables().add("SalesSummary", sheet.getCellRange("F3"), cache);

        // Apply a built-in Pivot Table style
        pivotTable.setBuiltInStyle(PivotBuiltInStyles.PivotStyleMedium10);

        // Save the result file
        workbook.saveToFile("CreatePivotTable.xlsx", ExcelVersion.Version2016);

        // Release resources
        workbook.dispose();
    }
}

After running the code, a Pivot Table named SalesSummary will be created at cell F3.

At this point, the Pivot Table structure is created, but fields still need to be configured.

Configure Pivot Table Fields

Pivot Table fields are mainly divided into two types:

Row Field: Used for grouping and displaying categories;
Data Field: Used for calculating summary values.

For example, to calculate sales amounts by region:

Set Region as the row field;
Add Sales Amount as the data field and calculate the total.

The following complete example opens the existing Pivot Table and configures the fields:

import com.spire.xls.*;
import com.spire.xls.core.IPivotField;

public class SetPivotFields {

    public static void main(String[] args) {

        // Create a Workbook object
        Workbook workbook = new Workbook();

        // Load the workbook containing the Pivot Table
        workbook.loadFromFile("CreatePivotTable.xlsx");

        // Get the worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        // Get the first Pivot Table
        PivotTable pivotTable = sheet.getPivotTables().get(0);

        // Get the Region field and set it as a row field
        IPivotField regionField = pivotTable.getPivotFields().get("Region");
        regionField.setAxis(AxisTypes.Row);

        // Add the Sales Amount field and calculate the sum
        pivotTable.getDataFields().add(pivotTable.getPivotFields().get("Sales Amount"), "Total Sales", SubtotalTypes.Sum);

        // Save the result
        workbook.saveToFile("ConfiguredPivotTable.xlsx", ExcelVersion.Version2016);

        // Release resources
        workbook.dispose();
    }
}

The generated Pivot Table will look similar to:

Region	Total Sales
East	8000
South	8000
North	6000

The Region field is used for grouping, while Sales Amount is used for calculation.

Add Multiple Data Fields

A Pivot Table can contain multiple summary fields.

For example, you may want to calculate both total sales amount and total sales quantity.

import com.spire.xls.*;

public class AddMultipleDataFields {

    public static void main(String[] args) {

        // Create a Workbook object
        Workbook workbook = new Workbook();

        // Load the workbook containing the Pivot Table
        workbook.loadFromFile("CreatePivotTable.xlsx");

        // Get the worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        // Get the Pivot Table
        PivotTable pivotTable = sheet.getPivotTables().get(0);

        // Add total sales amount
        pivotTable.getDataFields().add(pivotTable.getPivotFields().get("Sales Amount"), "Total Sales", SubtotalTypes.Sum);

        // Add total quantity
        pivotTable.getDataFields().add(pivotTable.getPivotFields().get("Quantity"), "Total Quantity", SubtotalTypes.Sum);

        // Save the file
        workbook.saveToFile("MultipleDataFields.xlsx", ExcelVersion.Version2016);

        // Release resources
        workbook.dispose();
    }
}

After adding multiple fields, the Pivot Table can display several metrics at the same time.

Save the Generated Excel File

After configuring the Pivot Table, save the result using saveToFile():

import com.spire.xls.*;

public class SavePivotTable {

    public static void main(String[] args) {

        // Create a Workbook object
        Workbook workbook = new Workbook();

        // Load the Excel file
        workbook.loadFromFile("ConfiguredPivotTable.xlsx");

        // Save the final file
        workbook.saveToFile("SalesAnalysisReport.xlsx", ExcelVersion.Version2016);

        // Release resources
        workbook.dispose();
    }
}

The generated Excel file can be opened directly in Microsoft Excel for further filtering or analysis.

Common Considerations

The Data Source Should Include Headers

When creating a Pivot Table, the first row should contain field names.

For example:

Correct:

Region	Product	Sales Amount
East	Phone	5000

Avoid:

A	B	C
East	Phone	5000

Field names are required when configuring Pivot Table fields.

Field Names Must Match Exactly

When setting fields:

pivotTable.getPivotFields().get("Region")

The field name must exactly match the header in the Excel data source.

Otherwise, the corresponding field cannot be found correctly.

Processing Large Data Sets

When working with large amounts of data:

Write data in batches instead of modifying cells repeatedly;
Avoid unnecessary worksheet operations;
Release the Workbook object after processing.

Conclusion

Pivot Tables are useful for grouping, summarizing, and analyzing structured Excel data.

By creating Pivot Tables with Java, developers can automate Excel report generation. After preparing the data source, you can configure fields and calculation methods programmatically to generate analysis-ready Excel files.

This approach is suitable for scenarios such as automated report generation and exporting Excel files with summarized data.

How to Extract Images and Image Information from PDF in Java

Dheeraj Malik — Wed, 23 Sep 2026 10:18:41 +0000

PDF files are widely used for storing reports, manuals, e-books, and other documents that combine text and visual content. Besides text, PDF documents often contain various image resources, including charts, diagrams, screenshots, scanned pages, and illustrations.

When processing PDF files programmatically, extracting images is often only part of the requirement. In many cases, developers also need additional information about those images, such as:

Which page contains the image
How many images exist on each page
The width and height of extracted images
The relationship between extracted images and the original document

This information is useful in scenarios such as document archiving, content analysis, and image resource management.

This article explains how to extract images from PDF files and retrieve image-related information using Java.

Preparing the Environment

Create a Java project and add the PDF processing dependency through Maven.

Add the following 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.9.0</version>
    </dependency>
</dependencies>

Then import the required classes:

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

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

Extract Images from PDF Files

Images in PDF documents are usually stored as page resources. To extract them, load the PDF file, iterate through each page, and retrieve the image information from each page.

The following example extracts all images from a PDF file and saves them as PNG images:

public class ExtractImages {

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

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("Sample.pdf");

        PdfImageHelper imageHelper = new PdfImageHelper();

        int imageIndex = 0;

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

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

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

            if (imageInfos != null) {

                for (PdfImageInfo imageInfo : imageInfos) {

                    BufferedImage image =
                            imageInfo.getImage();

                    ImageIO.write(
                            image,
                            "PNG",
                            new File("Image-" + imageIndex + ".png")
                    );

                    imageIndex++;
                }
            }
        }

        pdf.dispose();
    }
}

After execution, each extracted image will be saved as an independent PNG file.

For example:

Image-0.png
Image-1.png
Image-2.png

This approach is suitable for processing PDF files that contain multiple embedded images, such as reports, brochures, and technical documents.

Get the Number of Images in Each PDF Page

Before extracting images, you may want to check how many images exist in each page.

The following example counts images page by page:

public class CountImages {

    public static void main(String[] args) {

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("Sample.pdf");

        PdfImageHelper imageHelper = new PdfImageHelper();

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

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

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

            int count = imageInfos == null ? 0 : imageInfos.length;

            System.out.println(
                    "Page " + (i + 1)
                    + " contains "
                    + count
                    + " images"
            );
        }

        pdf.dispose();
    }
}

Output example:

Page 1 contains 3 images
Page 2 contains 5 images
Page 3 contains 1 images

This allows you to quickly understand how images are distributed throughout a PDF document.

Get Image Dimensions

Besides extracting image files, you can also retrieve the width and height of each image.

This information can help determine image quality or filter images based on specific requirements.

Example:

public class GetImageSize {

    public static void main(String[] args) {

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("Sample.pdf");

        PdfImageHelper imageHelper = new PdfImageHelper();

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

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

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

            if (imageInfos != null) {

                for (PdfImageInfo imageInfo : imageInfos) {

                    BufferedImage image =
                            imageInfo.getImage();

                    System.out.println(
                            "Width: "
                            + image.getWidth()
                            + ", Height: "
                            + image.getHeight()
                    );
                }
            }
        }

        pdf.dispose();
    }
}

Output example:

Width: 1200, Height: 800
Width: 640, Height: 480

With image dimensions, you can identify high-resolution images or classify extracted resources for further processing.

Extract Images with Page Information

In practical applications, saving image files alone is often not enough.

For example, a PDF report may contain dozens of images. During later processing, you may need to know which page each image came from.

You can include page numbers in the output filenames:

public class ExtractImagesWithPageInfo {

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

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("Sample.pdf");

        PdfImageHelper imageHelper = new PdfImageHelper();

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

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

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

            if (imageInfos != null) {

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

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

                    String fileName =
                            "Page-"
                            + (pageIndex + 1)
                            + "-Image-"
                            + (imageIndex + 1)
                            + ".png";

                    ImageIO.write(
                            image,
                            "PNG",
                            new File(fileName)
                    );
                }
            }
        }

        pdf.dispose();
    }
}

The generated files will keep their original page references:

Page-1-Image-1.png
Page-1-Image-2.png
Page-2-Image-1.png

This naming approach makes it easier to trace extracted images back to their original locations.

Conclusion

Extracting images from PDF files is not only about saving image files. In real-world applications, information such as image count, dimensions, and page references can be equally important.

By processing PDF pages and retrieving image information in Java, developers can automate image extraction and resource analysis for document management, content analysis, and data processing workflows.

How to Add Data Validation to Excel in Java (Step-by-Step)

Dheeraj Malik — Tue, 15 Sep 2026 16:00:00 +0000

Excel data validation is useful when a worksheet is meant to be filled in by other people. Instead of accepting any value, a cell can be limited to a number range, a date period, a certain text length, or a predefined list of choices.

This is especially helpful for forms and reusable templates, where inconsistent input can create extra cleanup work later.

In this tutorial, we’ll add several common validation rules to an Excel worksheet with Java, including whole number, date, text length, list, and time validation.

Common Excel Data Validation Types

Excel supports several validation types for different kinds of input:

Validation Type	Typical Use
Whole number	Quantities, counts, IDs
Decimal	Prices, percentages, measurements
List	Status, department, category
Date	Deadlines, submission dates, schedules
Time	Appointments, shifts, working hours
Text length	Codes, abbreviations, identifiers

Most rules are built from three parts: the allowed data type, a comparison operator, and one or two limits.

For example, a quantity field may accept only whole numbers from 1 to 100, while a date field may allow only dates within a given year.

Environment Setup

Add the required Excel processing dependency to your Java project.

For Maven, add the following 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.xls</artifactId>
        <version>16.8.4</version>
    </dependency>
</dependencies>

Import the required classes:

import com.spire.xls.*;

Step 1: Create a Workbook and Access the Worksheet

Create a workbook and get the first worksheet:

Workbook workbook = new Workbook();

Worksheet sheet = workbook.getWorksheets().get(0);

To make the sample worksheet easier to test, add a label for each validation type:

sheet.getCellRange("B2").setText("Whole Number Validation:");
sheet.getCellRange("B4").setText("Date Validation:");
sheet.getCellRange("B6").setText("Text Length Validation:");
sheet.getCellRange("B8").setText("List Validation:");
sheet.getCellRange("B10").setText("Time Validation:");

The corresponding input cells will be placed in column C.

Step 2: Apply Data Validation

Whole Number Validation

Suppose C2 is used for a quantity and should accept only whole numbers from 1 to 100:

CellRange rangeNumber = sheet.getCellRange("C2");

// Allow whole numbers only
rangeNumber.getDataValidation()
        .setAllowType(CellDataType.Integer);

// Restrict the value to a range
rangeNumber.getDataValidation()
        .setCompareOperator(
                ValidationComparisonOperator.Between
        );

// Set the minimum and maximum values
rangeNumber.getDataValidation().setFormula1("1");
rangeNumber.getDataValidation().setFormula2("100");

// Show an input prompt
rangeNumber.getDataValidation()
        .setInputMessage("Enter a whole number between 1 and 100");

// Highlight the input cell
rangeNumber.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

This kind of rule works well for quantities, headcounts, inventory levels, and similar fields where decimal values should not be accepted.

Date Validation

For C4, limit the input to dates within 2026:

CellRange rangeDate = sheet.getCellRange("C4");

// Allow dates only
rangeDate.getDataValidation()
        .setAllowType(CellDataType.Date);

// Restrict the date to a specific range
rangeDate.getDataValidation()
        .setCompareOperator(
                ValidationComparisonOperator.Between
        );

// Set the start and end dates
rangeDate.getDataValidation()
        .setFormula1("1/1/2026");

rangeDate.getDataValidation()
        .setFormula2("12/31/2026");

// Show an input prompt
rangeDate.getDataValidation()
        .setInputMessage(
                "Enter a date between 1/1/2026 and 12/31/2026"
        );

rangeDate.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

The comparison does not have to use Between. For a deadline field, for example, you could allow only dates on or after a certain day.

Text Length Validation

Text length validation is useful for fields such as internal codes, abbreviations, or short identifiers.

Here, C6 is limited to 10 characters:

CellRange rangeTextLength =
        sheet.getCellRange("C6");

// Validate the length of the entered text
rangeTextLength.getDataValidation()
        .setAllowType(CellDataType.TextLength);

// Limit the text to 10 characters
rangeTextLength.getDataValidation()
        .setCompareOperator(
                ValidationComparisonOperator.LessOrEqual
        );

rangeTextLength.getDataValidation()
        .setFormula1("10");

// Show an input prompt
rangeTextLength.getDataValidation()
        .setInputMessage(
                "Enter no more than 10 characters"
        );

rangeTextLength.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

If a field must contain an exact number of characters, the comparison operator can be changed accordingly.

List Validation

For fields with a fixed set of values, a drop-down list helps avoid variations in spelling and wording.

The code below adds a department list to C8:

CellRange rangeList =
        sheet.getCellRange("C8");

// Define the available choices
rangeList.getDataValidation().setValues(
        new String[]{
                "Development",
                "Testing",
                "Marketing",
                "Finance"
        }
);

// Show the drop-down arrow
rangeList.getDataValidation()
        .isSuppressDropDownArrow(false);

// Show an input prompt
rangeList.getDataValidation()
        .setInputMessage("Select a department from the list");

rangeList.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

For a short, stable list, defining the values directly in code is usually sufficient.

If the list changes frequently, it is better to keep the values in a worksheet range and use that range as the validation source.

Time Validation

C10 can be restricted to times between 9:00 and 18:00:

CellRange rangeTime =
        sheet.getCellRange("C10");

// Allow time values only
rangeTime.getDataValidation()
        .setAllowType(CellDataType.Time);

// Restrict the value to a time range
rangeTime.getDataValidation()
        .setCompareOperator(
                ValidationComparisonOperator.Between
        );

rangeTime.getDataValidation()
        .setFormula1("9:00");

rangeTime.getDataValidation()
        .setFormula2("18:00");

// Show an input prompt
rangeTime.getDataValidation()
        .setInputMessage(
                "Enter a time between 9:00 and 18:00"
        );

rangeTime.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

This can be useful for appointment times, work shifts, or any field that should stay within defined working hours.

Step 3: Adjust the Worksheet Layout

A little formatting makes the generated sheet easier to use:

// Auto-fit column B
sheet.autoFitColumn(2);

// Set the width of column C
sheet.setColumnWidth(3, 20);

Step 4: Save the Workbook

Save the finished workbook:

workbook.saveToFile(
        "DataValidation.xlsx",
        ExcelVersion.Version2016
);

workbook.dispose();

The generated worksheet now contains five different validation rules:

C2 accepts whole numbers from 1 to 100.
C4 accepts dates within 2026.
C6 accepts up to 10 characters.
C8 provides a department drop-down list.
C10 accepts times between 9:00 and 18:00.

These rules stay with the workbook, so the same input restrictions apply whenever the file is reused as a template.

How to Extract Tables from Word Documents with Python

Dheeraj Malik — Tue, 15 Sep 2026 03:41:03 +0000

Word documents often use tables to store structured information such as inventory lists, inspection records, project data, and reports. Extracting one table manually is simple enough, but it quickly becomes tedious when a document contains several tables or when many Word files need to be processed.

With Python, you can read the rows and cells of a Word table and convert the content into a structure that is easier to reuse or export.

This guide covers how to read a table from a Word document, extract all tables to CSV files, and process multiple Word files in a folder.

Environment Setup

To run the examples below, install the required Python module for Word processing:

pip install Spire.Doc

Read a Table from a Word Document

A Word table can be accessed through its section and then read row by row.

The example below reads the first table in the first section and stores its content in a two-dimensional Python list:

from spire.doc import *
from spire.doc.common import *

input_file = "input.docx"

document = Document()
document.LoadFromFile(input_file)

section = document.Sections.get_Item(0)
table = section.Tables.get_Item(0)

table_data = []

for r in range(table.Rows.Count):
    row = table.Rows.get_Item(r)
    row_data = []

    for c in range(row.Cells.Count):
        cell = row.Cells.get_Item(c)

        paragraphs = []

        for p in range(cell.Paragraphs.Count):
            text = cell.Paragraphs.get_Item(p).Text.strip()

            if text:
                paragraphs.append(text)

        row_data.append(" ".join(paragraphs))

    table_data.append(row_data)

for row in table_data:
    print(row)

document.Close()

A table cell may contain more than one paragraph, so the code reads all paragraphs in the cell instead of assuming that only one exists.

The extracted data may look like this:

[
    ["Name", "Department", "Position"],
    ["John Smith", "Development", "Software Engineer"],
    ["Emma Lee", "Testing", "QA Engineer"]
]

If the original paragraph breaks need to be preserved, replace:

" ".join(paragraphs)

with:

"\n".join(paragraphs)

Extract All Tables from Word to CSV

A Word document may contain tables in more than one section. To extract all of them, iterate through every section and its Tables collection.

The following code saves each table as a separate CSV file:

import csv
import os
from spire.doc import *
from spire.doc.common import *

input_file = "input.docx"
output_folder = "ExtractedTables"

os.makedirs(output_folder, exist_ok=True)

document = Document()
document.LoadFromFile(input_file)

table_number = 0

for s in range(document.Sections.Count):
    section = document.Sections.get_Item(s)

    for t in range(section.Tables.Count):
        table = section.Tables.get_Item(t)
        table_number += 1

        output_file = os.path.join(
            output_folder,
            f"table_{table_number}.csv"
        )

        with open(
            output_file,
            "w",
            newline="",
            encoding="utf-8-sig"
        ) as csv_file:

            writer = csv.writer(csv_file)

            for r in range(table.Rows.Count):
                row = table.Rows.get_Item(r)
                row_data = []

                for c in range(row.Cells.Count):
                    cell = row.Cells.get_Item(c)

                    paragraphs = []

                    for p in range(cell.Paragraphs.Count):
                        text = cell.Paragraphs.get_Item(p).Text.strip()

                        if text:
                            paragraphs.append(text)

                    row_data.append(" ".join(paragraphs))

                writer.writerow(row_data)

document.Close()

print(f"Extracted {table_number} tables.")

If the document contains three tables, the output folder will look like this:

ExtractedTables/
├── table_1.csv
├── table_2.csv
└── table_3.csv

The CSV files use utf-8-sig, which helps avoid encoding problems when text containing non-ASCII characters is opened directly in spreadsheet applications such as Excel.

Batch Extract Tables from Multiple Word Files

For multiple documents, it is cleaner to move the extraction logic into a reusable function instead of repeating the same code for every file.

import csv
import os
from spire.doc import *
from spire.doc.common import *


def extract_tables(word_file, output_folder):
    os.makedirs(output_folder, exist_ok=True)

    document = Document()
    document.LoadFromFile(word_file)

    table_number = 0

    for s in range(document.Sections.Count):
        section = document.Sections.get_Item(s)

        for t in range(section.Tables.Count):
            table = section.Tables.get_Item(t)
            table_number += 1

            output_file = os.path.join(
                output_folder,
                f"table_{table_number}.csv"
            )

            with open(
                output_file,
                "w",
                newline="",
                encoding="utf-8-sig"
            ) as csv_file:

                writer = csv.writer(csv_file)

                for r in range(table.Rows.Count):
                    row = table.Rows.get_Item(r)
                    row_data = []

                    for c in range(row.Cells.Count):
                        cell = row.Cells.get_Item(c)

                        text = " ".join(
                            cell.Paragraphs.get_Item(p).Text.strip()
                            for p in range(cell.Paragraphs.Count)
                            if cell.Paragraphs.get_Item(p).Text.strip()
                        )

                        row_data.append(text)

                    writer.writerow(row_data)

    document.Close()

    return table_number


input_folder = "WordFiles"
output_folder = "ExtractedTables"

for file_name in os.listdir(input_folder):

    if not file_name.lower().endswith((".doc", ".docx")):
        continue

    input_file = os.path.join(input_folder, file_name)

    document_name = os.path.splitext(file_name)[0]

    document_output = os.path.join(
        output_folder,
        document_name
    )

    count = extract_tables(
        input_file,
        document_output
    )

    print(f"{file_name}: extracted {count} tables")

Each document gets its own output folder, so tables from different files do not overwrite one another:

ExtractedTables/
├── report/
│   ├── table_1.csv
│   └── table_2.csv
├── inventory/
│   └── table_1.csv
└── records/
    ├── table_1.csv
    └── table_2.csv

A Note on Merged Cells

Merged cells need extra attention when exporting Word tables to CSV.

Word supports both horizontal and vertical cell merging, while CSV only stores rows and columns and has no concept of merged cells. As a result, a complex Word table may not map cleanly to a flat CSV structure.

If the extracted data will be imported into a database or used for analysis, it is worth checking tables with merged headers or grouped rows and normalizing them as needed after extraction.