JEditorPaneHTMLEditorKitParserSort排序算法

wen java案例 2026-07-25 163

本文目录导读：

HTML 内容提取与排序
使用 DOM 解析器进行排序
简单字符串解析排序
完整表格行列排序示例
选择建议

我为您的需求整理了几种适合在 JEditorPane/HTMLEditorKit 环境中使用的 HTML 解析和排序算法实现方案。

HTML 内容提取与排序

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.text.html.*;
import java.io.*;
import java.util.*;
public class HTMLSortExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("HTML Sorting Demo");
        JEditorPane editorPane = new JEditorPane();
        editorPane.setContentType("text/html");
        editorPane.setEditable(false);
        // 示例 HTML
        String html = "<html><body>" +
                      "<h1>Items</h1>" +
                      "<ul>" +
                      "<li>Banana</li>" +
                      "<li>Apple</li>" +
                      "<li>Cherry</li>" +
                      "<li>Date</li>" +
                      "</ul>" +
                      "</body></html>";
        editorPane.setText(html);
        // 排序按钮
        JButton sortBtn = new JButton("Sort Items");
        sortBtn.addActionListener(e -> {
            String sortedHtml = sortHTMLList(html, false);
            editorPane.setText(sortedHtml);
        });
        JPanel panel = new JPanel(new BorderLayout());
        panel.add(new JScrollPane(editorPane), BorderLayout.CENTER);
        panel.add(sortBtn, BorderLayout.SOUTH);
        frame.add(panel);
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
    // 提取并排序 HTML 列表内容
    public static String sortHTMLList(String html, boolean descending) {
        try {
            HTMLEditorKit kit = new HTMLEditorKit();
            HTMLDocument doc = (HTMLDocument) kit.createDefaultDocument();
            kit.read(new StringReader(html), doc, 0);
            // 提取所有列表项
            Element root = doc.getDefaultRootElement();
            List<String> items = new ArrayList<>();
            List<Element> liElements = new ArrayList<>();
            extractListItems(root, items, liElements);
            // 排序
            if (descending) {
                items.sort(Collections.reverseOrder());
            } else {
                Collections.sort(items);
            }
            // 重建 HTML
            return rebuildHTML(html, items, liElements);
        } catch (Exception e) {
            e.printStackTrace();
            return html;
        }
    }
    private static void extractListItems(Element element, List<String> items, List<Element> liElements) {
        for (int i = 0; i < element.getElementCount(); i++) {
            Element child = element.getElement(i);
            if ("li".equals(child.getName())) {
                try {
                    int start = child.getStartOffset();
                    int end = child.getEndOffset();
                    String text = child.getDocument().getText(start, end - start).trim();
                    items.add(text);
                    liElements.add(child);
                } catch (BadLocationException e) {
                    e.printStackTrace();
                }
            }
            extractListItems(child, items, liElements);
        }
    }
    private static String rebuildHTML(String originalHtml, List<String> sortedItems, List<Element> liElements) {
        // 直接替换文本内容的简化实现
        StringBuilder sb = new StringBuilder(originalHtml);
        // 从后往前替换，避免位置偏移
        for (int i = liElements.size() - 1; i >= 0; i--) {
            Element li = liElements.get(i);
            try {
                int start = li.getStartOffset();
                int end = li.getEndOffset();
                String originalText = li.getDocument().getText(start, end - start);
                // 在原始 HTML 中找到这个文本并替换
                int htmlIndex = sb.indexOf(originalText);
                if (htmlIndex >= 0) {
                    sb.replace(htmlIndex, htmlIndex + originalText.length(), sortedItems.get(i));
                }
            } catch (BadLocationException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
}

使用 DOM 解析器进行排序

import javax.swing.text.html.parser.*;
import javax.swing.text.html.*;
import javax.swing.text.*;
import java.util.*;
public class DOMSortExample {
    public static String sortHTMLByTags(String html, String tagName) {
        try {
            HTMLEditorKit kit = new HTMLEditorKit();
            HTMLDocument doc = (HTMLDocument) kit.createDefaultDocument();
            kit.read(new StringReader(html), doc, 0);
            // 查找指定标签的所有元素
            ElementIterator iterator = new ElementIterator(doc);
            Element element;
            List<SortableElement> elements = new ArrayList<>();
            while ((element = iterator.next()) != null) {
                if (tagName.equals(element.getName())) {
                    String text = getElementText(doc, element);
                    elements.add(new SortableElement(element, text));
                }
            }
            // 按文本排序
            elements.sort(Comparator.comparing(e -> e.text));
            // 返回排序后的 HTML
            return buildSortedHTML(doc, elements, tagName);
        } catch (Exception e) {
            e.printStackTrace();
            return html;
        }
    }
    private static String getElementText(HTMLDocument doc, Element element) {
        try {
            int start = element.getStartOffset();
            int end = element.getEndOffset();
            return doc.getText(start, end - start).trim();
        } catch (BadLocationException e) {
            return "";
        }
    }
    private static String buildSortedHTML(HTMLDocument doc, List<SortableElement> sortedElements, String tagName) {
        // 这里实现重建 HTML 的逻辑
        // 简化版本直接返回原始文档的字符串
        StringBuilder result = new StringBuilder();
        try {
            StringWriter writer = new StringWriter();
            new HTMLEditorKit().write(writer, doc, 0, doc.getLength());
            result.append(writer.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result.toString();
    }
    static class SortableElement {
        Element element;
        String text;
        SortableElement(Element element, String text) {
            this.element = element;
            this.text = text;
        }
    }
}

简单字符串解析排序

import java.util.*;
import java.util.regex.*;
public class StringBasedHTMLSort {
    // 按 HTML 标签内容排序
    public static String sortByTagContent(String html, String tag) {
        String regex = "<" + tag + "[^>]*>(.*?)</" + tag + ">";
        Pattern pattern = Pattern.compile(regex, Pattern.DOTALL);
        Matcher matcher = pattern.matcher(html);
        List<MatchPair> matches = new ArrayList<>();
        while (matcher.find()) {
            matches.add(new MatchPair(matcher.start(), matcher.end(), matcher.group()));
        }
        // 按内容排序
        matches.sort((a, b) -> {
            String aContent = extractContent(a.text, tag);
            String bContent = extractContent(b.text, tag);
            return aContent.compareTo(bContent);
        });
        // 重建 HTML
        StringBuilder result = new StringBuilder();
        int lastEnd = 0;
        for (MatchPair match : matches) {
            result.append(html, lastEnd, match.start);
            result.append(match.text);
            lastEnd = match.end;
        }
        result.append(html.substring(lastEnd));
        return result.toString();
    }
    private static String extractContent(String tagHtml, String tag) {
        Pattern pattern = Pattern.compile("<" + tag + "[^>]*>(.*?)</" + tag + ">", Pattern.DOTALL);
        Matcher matcher = pattern.matcher(tagHtml);
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        return "";
    }
    static class MatchPair {
        int start, end;
        String text;
        MatchPair(int start, int end, String text) {
            this.start = start;
            this.end = end;
            this.text = text;
        }
    }
    // 使用示例
    public static void main(String[] args) {
        String html = "<div>" +
                      "<p>Banana</p>" +
                      "<p>Apple</p>" +
                      "<p>Cherry</p>" +
                      "</div>";
        String sorted = sortByTagContent(html, "p");
        System.out.println("Original: " + html);
        System.out.println("Sorted: " + sorted);
    }
}

完整表格行列排序示例

import javax.swing.*;
import javax.swing.table.*;
import java.awt.*;
public class JEditorPaneTableSorter extends JFrame {
    public JEditorPaneTableSorter() {
        setTitle("HTML Table Sorter");
        setLayout(new BorderLayout());
        JEditorPane editorPane = new JEditorPane();
        editorPane.setContentType("text/html");
        editorPane.setEditable(false);
        String tableHtml = "<html><body>" +
                          "<table border='1'>" +
                          "<tr><th>Name</th><th>Age</th><th>City</th></tr>" +
                          "<tr><td>Alice</td><td>30</td><td>NYC</td></tr>" +
                          "<tr><td>Bob</td><td>25</td><td>LA</td></tr>" +
                          "<tr><td>Charlie</td><td>35</td><td>Chicago</td></tr>" +
                          "</table></body></html>";
        editorPane.setText(tableHtml);
        JButton sortByNameBtn = new JButton("Sort by Name");
        JButton sortByAgeBtn = new JButton("Sort by Age");
        JButton sortByCityBtn = new JButton("Sort by City");
        sortByNameBtn.addActionListener(e -> {
            String sorted = sortTableByColumn(tableHtml, 0);
            editorPane.setText(sorted);
        });
        sortByAgeBtn.addActionListener(e -> {
            String sorted = sortTableByColumn(tableHtml, 1);
            editorPane.setText(sorted);
        });
        sortByCityBtn.addActionListener(e -> {
            String sorted = sortTableByColumn(tableHtml, 2);
            editorPane.setText(sorted);
        });
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(sortByNameBtn);
        buttonPanel.add(sortByAgeBtn);
        buttonPanel.add(sortByCityBtn);
        add(new JScrollPane(editorPane), BorderLayout.CENTER);
        add(buttonPanel, BorderLayout.SOUTH);
        setSize(500, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }
    private String sortTableByColumn(String html, int columnIndex) {
        // 解析表格并排序
        String[] rows = html.split("</tr>");
        if (rows.length < 2) return html;
        // 分离表头和表体
        String header = rows[0] + "</tr>";
        List<String> bodyRows = new ArrayList<>();
        for (int i = 1; i < rows.length; i++) {
            bodyRows.add(rows[i] + "</tr>");
        }
        // 按指定列排序
        bodyRows.sort((r1, r2) -> {
            String[] cols1 = r1.split("</td>");
            String[] cols2 = r2.split("</td>");
            if (columnIndex < cols1.length && columnIndex < cols2.length) {
                String val1 = cols1[columnIndex].replaceAll("<[^>]+>", "").trim();
                String val2 = cols2[columnIndex].replaceAll("<[^>]+>", "").trim();
                return val1.compareTo(val2);
            }
            return 0;
        });
        // 重建 HTML
        StringBuilder sorted = new StringBuilder(header);
        for (String row : bodyRows) {
            sorted.append(row);
        }
        // 确保 HTML 结构完整
        String result = sorted.toString();
        if (!result.startsWith("<html>")) {
            result = "<html><body><table border='1'>" + result + "</table></body></html>";
        }
        return result;
    }
    public static void main(String[] args) {
        SwingUtilities.invokeLater(JEditorPaneTableSorter::new);
    }
}