Manipulating XML Documents with Java's DOM API

Use DocumentBuilderFactory and DocumentBuilder to parse an XML file into a DOM tree for manipulation. 2. Navigate and modify elements using getElementsByTagName and setTextContent, or modify attributes with setAttribute and removeAttribute. 3. Add new nodes via createElement and appendChild, and remove nodes by calling removeChild on the parent. 4. Save changes back to a file using Transformer with DOMSource and StreamResult, optionally enabling indentation for readability. The Java DOM API provides a built-in, memory-intensive but reliable way to fully manipulate XML documents programmatically, best suited for small to medium files.

Working with XML in Java often means needing to read, modify, or generate XML content programmatically. One of the most straightforward and widely used approaches is using Java’s built-in DOM (Document Object Model) API. DOM loads the entire XML document into memory as a tree structure, allowing full random access and manipulation. Here’s how you can effectively manipulate XML documents using Java’s DOM API.

1. Parsing an XML Document

Before you can manipulate an XML file, you need to parse it into a DOM tree. This is done using DocumentBuilder and DocumentBuilderFactory.

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import java.io.File;

public class XMLManipulator {
    public static Document parseXML(String filePath) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        return builder.parse(new File(filePath));
    }
}

• DocumentBuilderFactory creates the builder.
• DocumentBuilder parses the XML file into a Document object — the root of the DOM tree.
• The document is now in memory and ready for manipulation.

⚠️ Note: DOM loads the entire document into memory, so it's best suited for small to medium-sized XML files.

2. Navigating and Modifying Elements

Once the document is loaded, you can traverse and modify nodes using standard DOM methods.

Example: Change the value of a specific element

Suppose you have this XML:

<book>
  <title>Java Programming</title>
  <author>John Doe</author>
</book>

To change the <title> value:

import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

public static void updateTitle(Document doc, String newTitle) {
    NodeList titleNodes = doc.getElementsByTagName("title");
    if (titleNodes.getLength() > 0) {
        titleNodes.item(0).setTextContent(newTitle);
    }
}

Accessing and modifying attributes:

Element book = (Element) doc.getElementsByTagName("book").item(0);
book.setAttribute("status", "updated");
// Removes attribute
book.removeAttribute("status");

3. Adding and Removing Nodes

DOM allows dynamic structure changes.

Add a new element:

public static void addPrice(Document doc, String priceValue) {
    Element price = doc.createElement("price");
    price.setTextContent(priceValue);

    Element root = doc.getDocumentElement(); // <book>
    root.appendChild(price);
}

Remove an element:

public static void removeAuthor(Document doc) {
    NodeList authors = doc.getElementsByTagName("author");
    if (authors.getLength() > 0) {
        Element author = (Element) authors.item(0);
        author.getParentNode().removeChild(author);
    }
}

? Remember: Removing a node requires calling removeChild() on its parent.

4. Writing the Modified XML Back to a File

After manipulation, save the changes using Transformer.

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;

public static void saveXML(Document doc, String outputPath) throws Exception {
    TransformerFactory transformerFactory = TransformerFactory.newInstance();
    Transformer transformer = transformerFactory.newTransformer();
    DOMSource source = new DOMSource(doc);

    StreamResult result = new StreamResult(new File(outputPath));
    transformer.transform(source, result);
}

You can also format the output (pretty-print) by setting output properties:

transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
transformer.setOutputProperty("indent", "yes");

Summary of Key Points

• DOM is tree-based and loads the whole document — good for random access.
• Use DocumentBuilderFactory and DocumentBuilder to parse.
• Modify content via setTextContent(), setAttribute(), appendChild(), etc.
• Always save changes using Transformer.
• Be cautious with memory usage for large XML files.

With these basics, you can read, edit, add, or delete elements and attributes in any XML document using Java’s standard DOM API — no external libraries required.

Basically, it’s not fancy, but it’s reliable and built right in.

The above is the detailed content of Manipulating XML Documents with Java's DOM API. For more information, please follow other related articles on the PHP Chinese website!