XQA
Back to Java
2026-01-126 min read

Document Reference (Java)

Learn Document Reference (Java) step by step with clear examples and exercises.

Title: Document Reference (Java)

Why This Matters

Understanding Java's Document Object Model (DOM) is essential for manipulating and navigating HTML documents programmatically, a crucial skill for web development tasks such as creating dynamic websites, data scraping, or automating browser actions. In this lesson, we delve deep into the practical aspects of using DOM in Java to interact with HTML documents.

Java DOM is an API that allows Java programs to parse, manipulate, and serialize documents conforming to the Extensible Markup Language (XML) or HyperText Markup Language (HTML). It provides a tree-like representation of an HTML document, enabling developers to navigate through elements, modify attributes, and change content dynamically.

Prerequisites

To follow along with this tutorial, you should have a good understanding of:

  • Basic Java programming concepts (variables, loops, functions)
  • Java Standard Edition (SE) 8 or later
  • Familiarity with HTML and XML structures
  • A text editor for writing and running Java programs

Important Concepts to Understand Before Starting

  • Nodes: The fundamental building blocks of an HTML document in the DOM. Each node represents a part of the document, such as elements, attributes, or text.
  • Elements: Represents an HTML tag with its content and attributes.
  • Attributes: Additional information associated with an element, such as id, class, or href.
  • Text nodes: Contains the actual content within an element.
  • Document: The root node of the DOM tree that represents the entire HTML document.

Core Concept

Java DOM is part of the Java Standard Edition (JSE) and can be found in the javax.xml.parsers package. To use it, you'll first need to import necessary classes:

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;

To parse an HTML document, you can use the DocumentBuilderFactory class to create a DocumentBuilder, which will then be used to build a Document object representing the parsed HTML:

public static Document getHTMLDocument(String html) throws Exception {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
InputSource inputSource = new InputSource(new StringReader(html));
return builder.parse(inputSource);
}

In the above code, we create a DocumentBuilderFactory instance and use it to build a DocumentBuilder. We then create an InputSource object with our HTML string and parse the document using the parse() method of the DocumentBuilder.

Parsing an HTML file instead of a string

To parse an HTML file, you can replace the StringReader with a FileInputStream:

File inputFile = new File("example.html");
InputSource inputSource = new InputSource(new FileInputStream(inputFile));
Document document = builder.parse(inputSource);

Core Concept - Navigating the DOM Tree

Now that we have a Document object representing our HTML, we can navigate through it using various methods provided by the DOM API:

  • getDocumentElement(): Returns the root element of the document.
  • getElementsByTagName(String name): Retrieves all elements with the specified tag name.
  • getChildNodes(): Gets all child nodes of a given node.
  • hasAttribute(String name): Checks if an element has the specified attribute.
  • getAttribute(String name): Retrieves the value of an element's attribute.
  • getNodeName(): Returns the tag name of an element.
  • getNodeType(): Gets the type of a node (e.g., ELEMENT_NODE, TEXT_NODE).
  • getNextSibling(): Retrieves the next sibling node in the same parent.
  • getParentNode(): Returns the parent node of a given node.

Worked Example

Let's consider an example where we want to extract all links from an HTML document:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Example Document</title>
</head>
<body>
<h1>Welcome to my website!</h1>
<a href="https://example.com">Example Link 1</a>
<a href="https://another-example.com">Example Link 2</a>
</body>
</html>

In Java, we can parse this HTML and extract the links as follows:

import java.io.File;
import javax.xml.parsers.*;
import org.w3c.dom.*;

public class Main {
public static void main(String[] args) throws Exception {
File htmlFile = new File("example.html");
Document document = getHTMLDocument(htmlFile);
NodeList linkNodes = document.getElementsByTagName("a");

for (int i = 0; i < linkNodes.getLength(); i++) {
Element linkElement = (Element) linkNodes.item(i);
String href = linkElement.getAttribute("href");
System.out.println("Link: " + href);
}
}

public static Document getHTMLDocument(File htmlFile) throws Exception {
FileInputStream inputStream = new FileInputStream(htmlFile);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(inputStream);
return document;
}
}

In this example, we first create a File object representing our HTML file and parse it using the getHTMLDocument() method. We then use the getElementsByTagName() method to retrieve all elements with the "a" tag (anchors), which represent links in HTML. For each link element, we extract the "href" attribute containing the URL and print it to the console.

Common Mistakes

  1. Not closing DocumentBuilderFactory: Remember to call factory.setFeature("http://xml.org/sax/features/namespace-prefixes", false); before creating a DocumentBuilder. This prevents namespace prefixes from being added to your HTML document, making it easier to work with.
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setFeature("http://xml.org/sax/features/namespace-prefixes", false);
// ...
  1. Not handling exceptions: Always surround your DOM manipulation code with a try-catch block to handle potential exceptions, such as parsing errors or NPEs when accessing non-existent elements.
try {
// DOM manipulation code here
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}

Common Mistake - Accessing non-existent elements or attributes

To avoid NullPointerExceptions when accessing non-existent elements or attributes, you can use methods like hasAttribute(), hasChildNodes(), and getElementsByTagName(). If you are unsure whether an element exists, wrap your code in a try-catch block to handle potential NPEs.

try {
if (linkElement.hasAttribute("href")) {
String href = linkElement.getAttribute("href");
System.out.println("Link: " + href);
} else {
System.err.println("Error: No 'href' attribute found for link element.");
}
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}

Practice Questions

  1. Given the following HTML snippet, write a Java program to extract all paragraphs and their text content.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Practice Question</title>
</head>
<body>
<p id="paragraph1">First Paragraph</p>
<p id="paragraph2">Second Paragraph with an ID</p>
<p>Third Paragraph</p>
</body>
</html>
  1. Write a Java program to validate an XML file using DOM, checking for well-formedness and validity against a DTD or XSD.
  1. Write a Java program that creates an HTML document with a title, header, and paragraph using the DOM API. Save the generated HTML to a file.

FAQ

  1. What is the difference between SAX and DOM parsers in Java?
  • SAX (Simple API for XML) is an event-based parser that processes XML documents by firing events as it encounters elements, attributes, and text nodes. It is useful for large XML files where memory consumption is a concern but may require more custom handling to achieve specific tasks.
  • DOM (Document Object Model) is a tree-like representation of an XML or HTML document that allows you to navigate, modify, and serialize the entire document in memory. It is ideal for manipulating complex structures, searching, and extracting data from documents but can be less efficient with large files due to its memory footprint.
  1. Why does my Java DOM program throw a NullPointerException when accessing an element's attribute or child node?
  • Ensure that the element exists before attempting to access its attributes or children by using methods like hasAttribute(), hasChildNodes(), and getElementsByTagName(). If you are unsure whether an element exists, wrap your code in a try-catch block to handle potential NPEs.
  1. How can I serialize (write) an XML document using Java DOM?
  • To write an XML document with Java DOM, first create a Document object and build the tree structure as needed. Then, use the TransformerFactory class to create a Transformer, which can be used to output the XML to a file or stream using the transform() method.
Transformer transformer = TransformerFactory.newInstance().newTransformer();
Source xmlSource = new DOMSource(document);
Result outputResult = new StreamResult(new File("output.xml"));
transformer.transform(xmlSource, outputResult);
Document Reference (Java) | Java | XQA Learn