JEditorPaneHTMLEditorKitParserReverse反转操作

wen java案例 2026-07-25 89

本文目录导读：

解析 HTML 后反向生成原始 HTML（序列化反向）
将 HTML 内容反转（如文字顺序反转）
反转 HTML 解析过程中的标签栈操作
复杂的 DOM 树反转（反转树结构）

针对 JEditorPane、HTMLEditorKit 以及 HTML 解析的“反转操作”（Reverse），我理解您的需求可能有以下几种情况，由于您的问题比较简短,我将覆盖最可能的几种解释：

解析 HTML 后反向生成原始 HTML（序列化反向）

有时在解析 HTML 后，修改了文档内容，需要将修改后的内容反向导出为 HTML 字符串。

操作示例：

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.text.html.*;
import java.io.*;
public class HTMLReverseExample {
    public static void main(String[] args) throws Exception {
        JEditorPane editorPane = new JEditorPane();
        editorPane.setContentType("text/html");
        editorPane.setText("<html><body><b>Hello</b> World</body></html>");
        // 模拟对内容进行修改
        HTMLDocument doc = (HTMLDocument) editorPane.getDocument();
        // ... 对 doc 进行操作 ...
        // === 反向操作：将文档内容导出为 HTML ===
        StringWriter writer = new StringWriter();
        try {
            // 使用 HTMLEditorKit 的 write 方法
            HTMLEditorKit kit = (HTMLEditorKit) editorPane.getEditorKit();
            // 参数: 输出流, 文档, 起始位置, 长度
            // 注意：直接从文档写入可能会包含内部格式信息
            kit.write(writer, doc, 0, doc.getLength());
            String reversedHTML = writer.toString();
            System.out.println("Reversed HTML: " + reversedHTML);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            writer.close();
        }
    }
}

将 HTML 内容反转（如文字顺序反转）

如果您指的是将 HTML 内容中的文本进行反转（如 "Hello" → "olleH"），但保持 HTML 标签结构不变。

操作示例：

import javax.swing.text.html.*;
import javax.swing.text.*;
import javax.swing.*;
import java.util.regex.*;
public class HTMLContentReverser {
    public static String reverseHTMLContent(String html) {
        // 先解析为 HTMLDocument
        JEditorPane editorPane = new JEditorPane();
        editorPane.setContentType("text/html");
        editorPane.setText(html);
        HTMLDocument doc = (HTMLDocument) editorPane.getDocument();
        // 获取纯文本内容
        Element root = doc.getDefaultRootElement();
        StringBuilder textBuilder = new StringBuilder();
        // 遍历所有文本元素提取文本
        extractText(root, textBuilder);
        String originalText = textBuilder.toString();
        String reversedText = new StringBuilder(originalText).reverse().toString();
        // 替换文档中的文本内容，保持标签不变
        // 复杂实现，需要使用 Document 的 replace 方法
        return getHTMLFromDocument(doc);
    }
    private static void extractText(Element element, StringBuilder sb) {
        for (int i = 0; i < element.getElementCount(); i++) {
            Element child = element.getElement(i);
            if (child.getName().equals("content")) {
                try {
                    int start = child.getStartOffset();
                    int end = child.getEndOffset();
                    String text = child.getDocument().getText(start, end - start);
                    sb.append(text);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                extractText(child, sb);
            }
        }
    }
    private static String getHTMLFromDocument(HTMLDocument doc) {
        try {
            StringWriter writer = new StringWriter();
            HTMLEditorKit kit = new HTMLEditorKit();
            kit.write(writer, doc, 0, doc.getLength());
            return writer.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}

反转 HTML 解析过程中的标签栈操作

HTMLDocument 的解析过程会维护一个标签栈（Tag Stack），如果您需要反向操作这个栈（例如自定义解析器）,可以：

// 自定义 HTMLEditorKit.Parser 的 callback
HTMLEditorKit.ParserCallback callback = new HTMLEditorKit.ParserCallback() {
    @Override
    public void handleStartTag(HTML.Tag t, MutableAttributeSet a, int pos) {
        // 正向解析时处理开始标签
        // 反向操作可能在这里收集标签信息
    }
    @Override
    public void handleEndTag(HTML.Tag t, int pos) {
        // 反向操作可能在这里生成匹配的开始标签
    }
};

复杂的 DOM 树反转（反转树结构）

如果您需要反转 HTML 元素的嵌套结构（如深层嵌套反转）,这需要自定义算法：

// 伪代码示例
public void reverseElementStructure(Element element) {
    // 获取子元素
    int count = element.getElementCount();
    Element[] children = new Element[count];
    for (int i = 0; i < count; i++) {
        children[i] = element.getElement(i);
    }
    // 反转子元素顺序
    for (int i = 0; i < count / 2; i++) {
        Element temp = children[i];
        children[i] = children[count - 1 - i];
        children[count - 1 - i] = temp;
    }
    // 递归反转子元素
    for (Element child : children) {
        reverseElementStructure(child);
    }
}

请确认您的具体需求：