Edit HTML Documents in Java

Aspose.HTML for Java represents HTML as a Document Object Model (DOM) tree. After creating or loading an HTMLDocument, you can find elements, create or remove nodes, update attributes and text, set innerHTML, inspect outerHTML, and change inline or internal CSS.

To edit HTML in Java, create or load an HTMLDocument, locate the required DOM node, apply changes through methods such as createElement(), appendChild(), setAttribute(), or setInnerHTML(), and call save() to write the updated HTML. Render or convert the document only when another output format is required.

HTML DOM for Document Editing

The DOM represents a document as a tree of nodes. The document is the root, elements define its structure, attributes describe elements, and text nodes contain character data. Aspose.HTML follows WHATWG DOM concepts, so Java code can navigate and update the document through standard DOM-style operations.

The main types used in this article are:

Type	Purpose
Document	Represents the document tree and creates new nodes.
Node	Provides tree operations such as appending, inserting, replacing, and removing child nodes.
Element	Represents an element and provides access to attributes and element markup.
Text	Represents textual content within the DOM.
HTMLElement	Provides HTML-specific element features, including inline style access.

Common DOM Methods

Method	Use it to
getElementById()	Find the first element with a specific id.
getElementsByTagName()	Retrieve elements with the specified tag name.
createElement()	Create an element that can be configured and inserted into the DOM.
createTextNode()	Create a text node without parsing the text as HTML markup.
appendChild()	Add a node as the last child of another node.
insertBefore()	Insert a node before an existing child node.
removeChild()	Remove a child node from its parent.
setAttribute()	Add an attribute or replace its current value.
getAttribute()	Read an attribute value.

Edit an HTML Document Tree

The following example creates an HTML document, adds an internal style rule and a paragraph, saves the edited HTML, and renders the same DOM to PDF:

1. Create an empty HTMLDocument.
2. Create a <style> element, add a CSS class rule, and append it to the document <head>.
3. Create a paragraph, assign the CSS class, and append a text node.
4. Add the paragraph to the document body.
5. Save the edited document as HTML.
6. Create a PdfDevice with a PDF output path and call renderTo() to render the document.

// Create HTML document using DOM methods and convert to PDF in Aspose.HTML for Java

// Create an instance of the HTMLDocument class
HTMLDocument document = new HTMLDocument();

// Create a style element and assign the green color for all elements with class-name equals "gr"
Element style = document.createElement("style");
style.setTextContent(".gr { color: green }");

// Find the document header element and append the style element to the header
Element head = document.getElementsByTagName("head").get_Item(0);
head.appendChild(style);

// Create a paragraph element with class-name "gr"
HTMLParagraphElement p = (HTMLParagraphElement) document.createElement("p");
p.setClassName("gr");

// Create a text node
Text text = document.createTextNode("Hello, World!!");

// Append the text node to the paragraph
p.appendChild(text);

// Append the paragraph to the document body element
document.getBody().appendChild(p);

// Save the HTML document to a file
document.save("using-dom.html");

// Create an instance of the PDF output device and render the document into this device
PdfDevice device = new PdfDevice("using-dom.pdf");

// Render HTML to PDF
document.renderTo(device);

Before rendering, the saved HTML follows this structure:

<html>
    <head>
        <style>.gr { color: green }</style>
    </head>
    <body>
        <p class="gr">Hello, World!!</p>
    </body>
</html>

Edit Markup with setInnerHTML() and getOuterHTML()

Use setInnerHTML() to replace an element’s child markup. Use getOuterHTML() to read the serialized markup of the element itself together with its descendants.

1. Create an empty HTMLDocument and print the initial root markup.
2. Call setInnerHTML() on the document body with a paragraph fragment.
3. Call getOuterHTML() on the document element to print the updated HTML.

// Edit HTML body content and print the updated outerHTML using Aspose.HTML for Java

// Create an instance of the HTMLDocument class
HTMLDocument document = new HTMLDocument();

// Write the content of the HTML document into the console output
System.out.println(document.getDocumentElement().getOuterHTML());
// @output: <html><head></head><body></body></html>

// Set the content of the <body> element
document.getBody().setInnerHTML("<p>HTML is the standard markup language for Web pages.</p>");

// Write the content of the HTML document into the console output
System.out.println(document.getDocumentElement().getOuterHTML());
// @output: <html><head></head><body><p>HTML is the standard markup language for Web pages.</p></body></html>

setInnerHTML() parses the supplied string as markup and replaces the element’s existing descendants. When input must be treated only as text, use setTextContent() or create a text node instead.

Edit CSS in an HTML Document

Aspose.HTML can update CSS before the document is saved or converted. Use an element’s style attribute for declarations that apply to one element, or add a <style> element to the document <head> for rules that can target multiple elements.

Edit Inline CSS

Inline CSS is stored in an element’s style attribute. The following example applies a font size, font family, and color to a paragraph, saves the edited HTML, and renders it to PDF:

1. Create an HTMLDocument containing a paragraph.
2. Retrieve the paragraph element.
3. Set its style attribute with the required CSS declarations.
4. Save the edited HTML document.
5. Render the result through a PdfDevice that uses a .pdf output path.

// Edit inline CSS of an HTML element and render HTML to PDF using Aspose.HTML for Java

// Create an instance of an HTML document with specified content
String content = "<p> Inline CSS </p>";
try (HTMLDocument document = new HTMLDocument(content, ".")) {

    // Find the paragraph element to set a style attribute
    HTMLElement paragraph = (HTMLElement) document.getElementsByTagName("p").get_Item(0);

    // Set the style attribute
    paragraph.setAttribute("style", "font-size: 250%; font-family: verdana; color: #cd66aa");

    // Save the HTML document to a file
    document.save("edit-inline-css.html");

    // Create an instance of the PDF output device and render the document into this device
    try (PdfDevice device = new PdfDevice("edit-inline-css.pdf")) {
        document.renderTo(device);
    }
}

The rendered paragraph uses Verdana at 250% with the color #cd66aa:

Edit Internal CSS

Internal CSS is defined in a <style> element, usually inside the document <head>. The following example adds two class rules and assigns them to paragraphs. It also updates individual declarations through each paragraph’s getStyle() object, producing inline styles that override conflicting class declarations:

1. Create an HTMLDocument with two paragraphs.
2. Create a <style> element containing .frame1 and .frame2 rules and append it to the document <head>.
3. Assign the corresponding class name to each paragraph.
4. Use getStyle() to set additional inline declarations on the paragraphs.
5. Save the edited HTML and render it to PDF.

// Edit HTML with internal CSS using Java

// Create an instance of an HTML document with specified content
String content = "<div><p>Internal CSS</p><p>An internal CSS is used to define a style for a single HTML page</p></div>";
try (HTMLDocument document = new HTMLDocument(content, ".")) {

    // Create a style element with text content
    Element style = document.createElement("style");
    style.setTextContent(".frame1 { margin-top:50px; margin-left:50px; padding:20px; width:360px; height:90px; background-color:#a52a2a; font-family:verdana; color:#FFF5EE;} \r\n" +
            ".frame2 { margin-top:-90px; margin-left:160px; text-align:center; padding:20px; width:360px; height:100px; background-color:#ADD8E6;}");

    // Find the document header element and append the style element to the header
    Element head = document.getElementsByTagName("head").get_Item(0);
    head.appendChild(style);

    // Find the first paragraph element to inspect the styles
    HTMLElement paragraph = (HTMLElement) document.getElementsByTagName("p").get_Item(0);
    paragraph.setClassName("frame1");

    // Find the last paragraph element to inspect the styles
    HTMLElement lastParagraph = (HTMLElement) document.getElementsByTagName("p").get_Item(document.getElementsByTagName("p").getLength() - 1);
    lastParagraph.setClassName("frame2");

    // Set a font-size to the first paragraph
    paragraph.getStyle().setFontSize("250%");
    paragraph.getStyle().setTextAlign("center");

    // Set a color and font-size to the last paragraph
    lastParagraph.getStyle().setColor("#434343");
    lastParagraph.getStyle().setFontSize("150%");
    lastParagraph.getStyle().setFontFamily("verdana");

    // Save the HTML document to a file
    document.save("edit-internal-css.html");

    // Create an instance of the PDF output device and render the document on that device
    try (PdfDevice device = new PdfDevice("edit-internal-css.pdf")) {

        // Render HTML to PDF
        document.renderTo(device);
    }
}

The rendered PDF shows both paragraphs with the internal class rules and their additional inline declarations applied:

Common HTML Editing Issues

Issue	Cause and fix
An element lookup returns null	The element does not exist or the identifier does not match. Check the source DOM before accessing or casting the result.
Existing child elements disappear after setInnerHTML()	The method replaces all current descendants of the target element. Append nodes when existing children must be preserved.
Markup appears as visible text	Text content does not parse HTML tags. Use setInnerHTML() only for trusted markup that should become DOM nodes.
A CSS rule is not applied	Check that the <style> element is in the document, the selector matches, and another declaration does not override it.
Changes are missing from the saved file	DOM changes remain in memory until save() is called. Save after completing the edits.

FAQ

How do I edit an HTML document in Java?

Create or load an HTMLDocument, find or create the required nodes, update their content, attributes, or CSS, and call save() to write the edited document.

What is the difference between innerHTML and outerHTML?

innerHTML represents the markup inside an element. outerHTML includes the element’s own start and end tags together with its descendant markup.

Should I use setTextContent() or setInnerHTML()?

Use setTextContent() when a value must remain plain text. Use setInnerHTML() when trusted markup should be parsed into elements and text nodes. Do not pass untrusted HTML to setInnerHTML() without appropriate validation or sanitization.

How do I add CSS to an HTML document?

Use setAttribute("style", declarations) or getStyle() for inline CSS. For document-level rules, create a <style> element, set its CSS text, and append it to the document <head>.

Does editing an HTMLDocument automatically update the source file?

No. DOM changes affect the in-memory document. Call save() with an output path to persist them.

Other Platforms

• Edit HTML Documents in C# – update DOM nodes, attributes, text, links, and markup with Aspose.HTML for .NET.
• Edit HTML Documents in Python – edit HTML through the DOM with Aspose.HTML for Python via .NET.

Related Articles

• Working with HTML Documents in Java – choose a document creation, editing, configuration, or saving workflow.
• Create and Load HTML Documents in Java – create HTML from files, URLs, strings, streams, or DOM nodes.
• Save HTML Document in Java – save edited HTML and control linked-resource handling.
• HTML DOM Navigation in Java – navigate documents with DOM methods, CSS selectors, XPath, and traversal APIs.
• Fine-Tuning Converters in Java – configure PDF and other rendering outputs.
• Aspose.HTML for Java Examples on GitHub – download complete Java examples and supporting data files.