How to Modify HTML File Using Java?

In order to modify an HTML file using Java, we can use the Java DOM API. The DOM (Document Object Model) API is a platform-independent, language-neutral interface that allows programs and scripts to dynamically access and update the content, structure, and style of HTML documents. Here is an example Java program that modifies an HTML file by adding a new element to it:

ModifyHTML.java

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
public class ModifyHTML {
    public static void main(String[] args) {
        try {
            // Load the HTML file
            File inputFile = new File("input.html");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(inputFile);
            // Create a new element
            Element newElement = doc.createElement("p");
            newElement.setTextContent("This is a new paragraph.");
              // Add the new element to the document
            doc.getElementsByTagName("body").item(0).appendChild(newElement);
           // Save the modified document
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File("output.html"));
            transformer.transform(source, result);
            System.out.println("HTML file modified successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

The program loads an HTML file named "input.html", creates a new paragraph element, adds it to the document's body element, and saves the modified document to a new file named "output.html".Assuming that the "input.html" file contains the following HTML code:

<!DOCTYPE html>
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1>Welcome</h1>
    <p>This is an example HTML file.</p>
</body>
</html>

After running the above Java program, the "output.html" file will contain the following HTML code:

<!DOCTYPE html>
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1>Welcome</h1>
    <p>This is an example HTML file.</p>
    <p>This is a new paragraph.</p>
</body>
</html>

In addition to adding new elements to an HTML document, the Java DOM API can also be used to modify existing elements and attributes. For example, we can change the text content of an existing element, update the value of an attribute, or remove an element from the document. Here is an updated version of the Java program that modifies an HTML file by changing the text content of an existing paragraph element:

ModifyHTML.java

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
public class ModifyHTML {
    public static void main(String[] args) {
        try {
            // Load the HTML file
            File inputFile = new File("input.html");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(inputFile);
            // Find the paragraph element to modify
            NodeList paragraphs = doc.getElementsByTagName("p");
            Element paragraph = (Element) paragraphs.item(0);
             // Change the text content of the paragraph element
            paragraph.setTextContent("This paragraph has been modified.");
            // Save the modified document
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File("output.html"));
            transformer.transform(source, result);
             System.out.println("HTML file modified successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Assuming that the "input.html" file still contains the same HTML code as before, after running the above Java program, the "output.html" file will contain the following HTML code:

<!DOCTYPE html>
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1>Welcome</h1>
    <p>This paragraph has been modified.</p>
</body>
</html>

As you can see, the program successfully changed the text content of the first paragraph element in the document. The Java DOM API provides a powerful and flexible way to modify HTML documents programmatically. With this API, we can create new elements, modify existing elements and attributes, and remove elements from the document. Attributes are used to provide additional information about HTML elements, such as their styles, classes, IDs, and data values. We can use the DOM API to create new attributes, update existing attributes, and remove attributes from elements in the document. Here is an example Java program that modifies an HTML file by adding a new attribute to an existing element:

ModifyHTML.java

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
public class ModifyHTML {
    public static void main(String[] args) {
        try {
            // Load the HTML file
            File inputFile = new File("input.html");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(inputFile);
             // Find the element to modify
            Element heading = (Element) doc.getElementsByTagName("h1").item(0);
              // Add a new attribute to the element
            heading.setAttribute("class", "main-heading");
             // Save the modified document
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File("output.html"));
            transformer.transform(source, result);
            System.out.println("HTML file modified successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Assuming that the "input.html" file still contains the same HTML code as before, after running the above Java program, the "output.html" file will contain the following HTML code:

<!DOCTYPE html>
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1 class="main-heading">Welcome</h1>
    <p>This is an example HTML file.</p>
</body>
</html>

As you can see, the program successfully added a new "class" attribute to the heading element. In addition to adding new attributes, we can also modify and remove existing attributes using the Java DOM API. For example, we can change the value of a "class" attribute, remove a "style" attribute, or add a new "data" attribute. Using the DOM API, we can navigate through the document tree, access and modify the properties of individual elements, and perform operations on groups of elements. For example, we can select all elements of a certain type or with a certain attribute, and then modify their properties or remove them from the document. Here is an example Java program that modifies an HTML file by removing all paragraph elements that contain the word "example":

ModifyHTML.java

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class ModifyHTML {
    public static void main(String[] args) {
        try {
            // Load the HTML file
            File inputFile = new File("input.html");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(inputFile);
             // Find all paragraph elements that contain the word "example"
            NodeList paragraphs = doc.getElementsByTagName("p");
            for (int i = 0; i < paragraphs.getLength(); i++) {
                Element paragraph = (Element) paragraphs.item(i);
                String textContent = paragraph.getTextContent();
                if (textContent.contains("example")) {
                    // Remove the paragraph element
                    Node parent = paragraph.getParentNode();
                    parent.removeChild(paragraph);
                }
            }
           // Save the modified document
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File("output.html"));
            transformer.transform(source, result);
            System.out.println("HTML file modified successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Assuming that the "input.html" file contains the following HTML code:

<!DOCTYPE html>
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1>Welcome</h1>
    <p>This is an example HTML file.</p>
    <p>Here's another example paragraph.</p>
    <p>This paragraph does not contain the word "example".</p>
</body>
</html>

After running the above Java program, the "output.html" file will contain the following HTML code:

<!DOCTYPE html>
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1>Welcome</h1>
    <p>This paragraph does not contain the word "example".</p>
</body>
</html>

As we can see, the program successfully removed the two paragraph elements that contained the word "example", leaving only the paragraph that did not match the search criteria. With the ability to navigate the document tree, access and modify element properties, and perform operations on groups of elements, the DOM API offers a flexible and efficient way to automate tasks and manipulate web content. In addition to removing elements, the Java DOM API can also be used to add new elements, modify existing elements, and change the attributes of elements. Here is an example Java program that adds a new paragraph element to an HTML file:

ModifyHTML.java

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
public class ModifyHTML {
    public static void main(String[] args) {
        try {
            // Load the HTML file
            File inputFile = new File("input.html");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(inputFile);
           // Create a new paragraph element and add text
            Element newParagraph = doc.createElement("p");
            newParagraph.setTextContent("This is a new paragraph.");
             // Add the new paragraph element to the document
            Node body = doc.getElementsByTagName("body").item(0);
            body.appendChild(newParagraph);
            // Save the modified document
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File("output.html"));
            transformer.transform(source, result);
           System.out.println("HTML file modified successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Assuming that the "input.html" file contains the following HTML code:

<!DOCTYPE html>
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1>Welcome</h1>
    <p>This is an example HTML file.</p>
</body>
</html>

After running the above Java program, the "output.html" file will contain the following HTML code:

<!DOCTYPE html>
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1>Welcome</h1>
    <p>This is an example HTML file.</p>
    <p>This is a new paragraph.</p>
</body>
</html>

As we can see, the program successfully added a new paragraph element to the HTML file, immediately following the existing paragraph element. Overall, the Java DOM API provides a flexible and powerful set of tools for modifying HTML documents programmatically.

Next TopicJava 8 Multithreading Features

← prev next →