Last Updated: 

Converting DOC to DOCX in Java: A Comprehensive Guide

In the world of document processing, the need to convert files from one format to another is quite common. One such frequent conversion is from the older .doc format (Microsoft Word 97 - 2003) to the newer .docx format (Microsoft Word 2007 and later). The .docx format is based on the Office Open XML standard, which offers several advantages over the legacy .doc format, such as better data recovery, smaller file sizes, and improved security. Java, being a versatile and widely-used programming language, provides various ways to perform this conversion. In this blog post, we will explore the core concepts, typical usage scenarios, common pitfalls, and best practices for converting .doc to .docx in Java.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Prerequisites
  4. Code Examples
  5. Common Pitfalls
  6. Best Practices
  7. Conclusion
  8. FAQ
  9. References

Core Concepts#

DOC and DOCX Formats#

  • DOC: It is a binary file format used by Microsoft Word prior to 2007. It stores data in a proprietary binary structure, which makes it less flexible and more difficult to parse compared to modern formats.
  • DOCX: This is an XML-based format introduced in Microsoft Word 2007. It stores document content in a set of XML files compressed into a .zip archive. This makes it more open, easier to analyze, and more compatible with different software.

Java Libraries for Conversion#

  • Apache POI: It is a popular Java library for working with Microsoft Office file formats. It provides classes and methods to read, write, and manipulate .doc and .docx files.
  • Docx4j: Another library that focuses on working with Office Open XML (.docx) files. It can be used in combination with other libraries to perform the conversion.

Typical Usage Scenarios#

  • Data Migration: When migrating from an old system that uses the .doc format to a new one that requires .docx, conversion is necessary.
  • Compatibility: To ensure that documents can be opened and edited on modern software that has better support for the .docx format.
  • Automated Document Processing: In applications that need to process documents in bulk, converting all files to a single, more standardized format like .docx simplifies the processing.

Prerequisites#

  • Java Development Kit (JDK): You need to have JDK installed on your system. We recommend using JDK 8 or later.
  • Apache POI Library: You can download the Apache POI library from the official website or use a build tool like Maven or Gradle to manage the dependencies.

If you are using Maven, add the following dependencies to your pom.xml:

<dependencies>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>5.2.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>5.2.3</version>
    </dependency>
</dependencies>

Code Examples#

The following Java code demonstrates how to convert a .doc file to a .docx file using Apache POI:

import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;
 
import java.io.*;
 
public class DocToDocxConverter {
 
    public static void convertDocToDocx(String inputFilePath, String outputFilePath) {
        try (FileInputStream fis = new FileInputStream(new File(inputFilePath));
             HWPFDocument doc = new HWPFDocument(fis);
             WordExtractor extractor = new WordExtractor(doc);
             XWPFDocument docx = new XWPFDocument()) {
 
            // Get the text from the .doc file
            String[] paragraphs = extractor.getParagraphText();
 
            // Add each paragraph to the .docx file
            for (String paragraphText : paragraphs) {
                XWPFParagraph paragraph = docx.createParagraph();
                XWPFRun run = paragraph.createRun();
                run.setText(paragraphText);
            }
 
            // Write the .docx file to disk
            try (FileOutputStream fos = new FileOutputStream(new File(outputFilePath))) {
                docx.write(fos);
            }
 
            System.out.println("Conversion successful!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        String inputFilePath = "input.doc";
        String outputFilePath = "output.docx";
        convertDocToDocx(inputFilePath, outputFilePath);
    }
}

Code Explanation#

  1. Input File Reading: We first open the .doc file using FileInputStream and create a HWPFDocument object to represent the document.
  2. Text Extraction: We use WordExtractor to extract all the paragraphs from the .doc file.
  3. DOCX Document Creation: We create a new XWPFDocument object to represent the .docx file.
  4. Paragraph Addition: We iterate through each paragraph extracted from the .doc file and add it to the .docx document.
  5. Output File Writing: Finally, we write the .docx document to disk using FileOutputStream.

Common Pitfalls#

  • Formatting Loss: During the conversion, some advanced formatting like custom fonts, complex tables, and graphics may be lost. This is because the .doc and .docx formats have different ways of representing such elements.
  • Memory Issues: If you are dealing with very large .doc files, loading the entire document into memory can lead to OutOfMemoryError. You may need to process the document in chunks.
  • Dependency Management: Incorrectly managing the dependencies of the Apache POI library can lead to compilation errors or runtime exceptions.

Best Practices#

  • Error Handling: Always implement proper error handling in your code to handle exceptions such as IOException and OutOfMemoryError.
  • Testing: Test the conversion on a variety of .doc files, including those with different formatting and content, to ensure that the conversion works as expected.
  • Resource Management: Use try-with-resources statements to ensure that all file streams and document objects are properly closed after use.

Conclusion#

Converting .doc to .docx in Java can be achieved using libraries like Apache POI. By understanding the core concepts, typical usage scenarios, and following best practices, you can perform this conversion effectively. However, be aware of the common pitfalls, especially formatting loss and memory issues. With proper implementation and testing, you can use this technique in real-world applications for data migration, compatibility, and automated document processing.

FAQ#

Q1: Can I convert a .doc file with images to a .docx file?#

A: The basic conversion code provided above only handles text. To convert a .doc file with images, you need to extract the images from the .doc file and add them to the .docx file using the appropriate methods in the Apache POI library.

Q2: Is it possible to convert multiple .doc files at once?#

A: Yes, you can use a loop to iterate through a list of .doc files and call the conversion method for each file.

Q3: What if the input .doc file is password-protected?#

A: Apache POI's HWPF does not support reading password-protected .doc files. For password-protected .docx files, you need to provide the password when opening the document.

References#

2025-10