---
title: "将HTML转化为TEXT的Java类"
author: "mmdev"
date: "2005-10-19T11:00:00Z"
tags: []
slug: "html-text-java"
draft: false
lastmod: "2005-10-19T11:00:00Z"
id: 1006642
url: "https://mmdev.iteye.com/blog/1006642"
---

为了支持全文检索，有必要将HTML格式的文章转化为纯文本格式，因此我设计了一个基本的WebFormatter类，提供一个简单的public static String html2text(String html)，将HTML格式转化为Text：

/*  
\* File: WebFormatter.java  
\* Created on 2005-6-24  
\* Author: Liao Xuefeng, [asklxf@163.com](mailto:asklxf@163.com)  
\* Copyright (C) 2005, Liao Xuefeng.  
\*/  
package com.mboker.blog.web.util;

import java.util.\*;  
import java.text.SimpleDateFormat;

/\**  
\* Do some format on web display.  
\*  
\* @author Xuefeng  
\*/  
public class WebFormatter {

public static String html2text(String html) {  
StringBuffer sb = new StringBuffer(html.length());  
char\[] data = html.toCharArray();  
int start = 0;  
boolean previousIsPre = false;  
Token token = null;  
for(;;) {  
token = parse(data, start, previousIsPre);  
if(token==null)  
break;  
previousIsPre = token.isPreTag();  
sb = sb.append(token.getText());  
start += token.getLength();  
}  
return sb.toString();  
}

private static Token parse(char\[] data, int start, boolean previousIsPre) {  
if(start&gt;=data.length)  
return null;  
// try to read next char:  
char c = data\[start];  
if(c=='&lt;') {  
// this is a tag or comment or script:  
int end\_index = indexOf(data, start+1, '&gt;');  
if(end\_index==(-1)) {  
// the left is all text!  
return new Token(Token.TOKEN\_TEXT, data, start, data.length, previousIsPre);  
}  
String s = new String(data, start, end\_index-start+1);  
// now we got s="&lt;...&gt;":  
if(s.startsWith("&lt;!--")) { // this is a comment!  
int end\_comment\_index = indexOf(data, start+1, "--&gt;");  
if(end\_comment\_index==(-1)) {  
// illegal end, but treat as comment:  
return new Token(Token.TOKEN\_COMMENT, data, start, data.length, previousIsPre);  
}  
else  
return new Token(Token.TOKEN\_COMMENT, data, start, end\_comment\_index+3, previousIsPre);  
}  
String s\_lowerCase = s.toLowerCase();  
if(s\_lowerCase.startsWith("&lt;script")) { // this is a script:  
int end\_script\_index = indexOf(data, start+1, "&lt;/script&gt;");  
if(end\_script\_index==(-1))  
// illegal end, but treat as script:  
return new Token(Token.TOKEN\_SCRIPT, data, start, data.length, previousIsPre);  
else  
return new Token(Token.TOKEN\_SCRIPT, data, start, end\_script\_index+9, previousIsPre);  
}  
else { // this is a tag:  
return new Token(Token.TOKEN\_TAG, data, start, start+s.length(), previousIsPre);  
}  
}  
// this is a text:  
int next\_tag\_index = indexOf(data, start+1, '&lt;');  
if(next\_tag\_index==(-1))  
return new Token(Token.TOKEN\_TEXT, data, start, data.length, previousIsPre);  
return new Token(Token.TOKEN\_TEXT, data, start, next\_tag\_index, previousIsPre);  
}

private static int indexOf(char\[] data, int start, String s) {  
char\[] ss = s.toCharArray();  
// TODO: performance can improve!  
for(int i=start; i&lt;(data.length-ss.length); i++) {  
// compare from data\[i] with ss\[0]:  
boolean match = true;  
for(int j=0; j&lt;ss.length; j++) {  
if(data\[i+j]!=ss\[j]) {  
match = false;  
break;  
}  
}  
if(match)  
return i;  
}  
return (-1);  
}

private static int indexOf(char\[] data, int start, char c) {  
for(int i=start; i&lt;data.length; i++) {  
if(data\[i]==c)  
return i;  
}  
return (-1);  
}

}

class Token {

public static final int TOKEN\_TEXT = 0; // html text.  
public static final int TOKEN\_COMMENT = 1; // comment like &lt;!-- comments... --&gt;  
public static final int TOKEN\_TAG = 2; // tag like &lt;pre&gt;, &lt;font&gt;, etc.  
public static final int TOKEN\_SCRIPT = 3;

private static final char\[] TAG\_BR = "&lt;br".toCharArray();  
private static final char\[] TAG\_P = "&lt;p".toCharArray();  
private static final char\[] TAG\_LI = "&lt;li".toCharArray();  
private static final char\[] TAG\_PRE = "&lt;pre".toCharArray();  
private static final char\[] TAG\_HR = "&lt;hr".toCharArray();

private static final char\[] END\_TAG\_TD = "&lt;/td&gt;".toCharArray();  
private static final char\[] END\_TAG\_TR = "&lt;/tr&gt;".toCharArray();  
private static final char\[] END\_TAG\_LI = "&lt;/li&gt;".toCharArray();

private static final Map SPECIAL\_CHARS = new HashMap();

private int type;  
private String html; // original html  
private String text = null; // text!  
private int length = 0; // html length  
private boolean isPre = false; // isPre tag?

static {  
SPECIAL\_CHARS.put("&quot;", "\\"");  
SPECIAL\_CHARS.put("&lt;", "&lt;");  
SPECIAL\_CHARS.put("&gt;", "&gt;");  
SPECIAL\_CHARS.put("&amp;", "&");  
SPECIAL\_CHARS.put("&reg;", "(r)");  
SPECIAL\_CHARS.put("&copy;", "(c)");  
SPECIAL\_CHARS.put("&nbsp;", " ");  
SPECIAL\_CHARS.put("&pound;", "?");  
}

public Token(int type, char\[] data, int start, int end, boolean previousIsPre) {  
this.type = type;  
this.length = end - start;  
this.html = new String(data, start, length);  
System.out.println("\[Token] html=" + html + ".");  
parseText(previousIsPre);  
System.out.println("\[Token] text=" + text + ".");  
}

public int getLength() {  
return length;  
}

public boolean isPreTag() {  
return isPre;  
}

private void parseText(boolean previousIsPre) {  
if(type==TOKEN\_TAG) {  
char\[] cs = html.toCharArray();  
if(compareTag(TAG\_BR, cs) || compareTag(TAG\_P, cs))  
text = "\\n";  
else if(compareTag(TAG\_LI, cs))  
text = "\\n* ";  
else if(compareTag(TAG\_PRE, cs))  
isPre = true;  
else if(compareTag(TAG\_HR, cs))  
text = "\\n--------\\n";  
else if(compareString(END\_TAG\_TD, cs))  
text = "\\t";  
else if(compareString(END\_TAG\_TR, cs) || compareString(END\_TAG\_LI, cs))  
text = "\\n";  
}  
// text token:  
else if(type==TOKEN\_TEXT) {  
text = toText(html, previousIsPre);  
}  
}

public String getText() {  
return text==null ? "" : text;  
}

private String toText(String html, final boolean isPre) {  
char\[] cs = html.toCharArray();  
StringBuffer buffer = new StringBuffer(cs.length);  
int start = 0;  
boolean continueSpace = false;  
char current, next;  
for(;;) {  
if(start&gt;=cs.length)  
break;  
current = cs\[start]; // read current char  
if(start+1&lt;cs.length) // and next char  
next = cs\[start+1];  
else  
next = '\\0';  
if(current==' ') {  
if(isPre || !continueSpace)  
buffer = buffer.append(' ');  
continueSpace = true;  
// continue loop:  
start++;  
continue;  
}  
// not ' ', so:  
if(current=='\\r' && next=='\\n') {  
if(isPre)  
buffer = buffer.append('\\n');  
// continue loop:  
start+=2;  
continue;  
}  
if(current=='\\n' || current=='\\r') {  
if(isPre)  
buffer = buffer.append('\\n');  
// continue loop:  
start++;  
continue;  
}  
// cannot continue space:  
continueSpace = false;  
if(current=='&') {  
// maybe special char:  
int length = readUtil(cs, start, ';', 10);  
if(length==(-1)) { // just '&':  
buffer = buffer.append('&');  
// continue loop:  
start++;  
continue;  
}  
else { // check if special character:  
String spec = new String(cs, start, length);  
String specChar = (String)SPECIAL\_CHARS.get(spec);  
if(specChar!=null) { // special chars!  
buffer = buffer.append(specChar);  
// continue loop:  
start+=length;  
continue;  
}  
else { // check if like '&#1234':  
if(next=='#') { // maybe a char  
String num = new String(cs, start+2, length-3);  
try {  
int code = Integer.parseInt(num);  
if(code&gt;0 && code&lt;65536) { // this is a special char:  
buffer = buffer.append((char)code);  
// continue loop:  
start++;  
continue;  
}  
}  
catch(Exception e) {}  
// just normal char:  
buffer = buffer.append("&#");  
// continue loop:  
start+=2;  
continue;  
}  
else { // just '&':  
buffer = buffer.append('&');  
// continue loop:  
start++;  
continue;  
}  
}  
}  
}  
else { // just a normal char!  
buffer = buffer.append(current);  
// continue loop:  
start++;  
continue;  
}  
}  
return buffer.toString();  
}

// read from cs\[start] util meet the specified char 'util',  
// or null if not found:  
private int readUtil(final char\[] cs, final int start, final char util, final int maxLength) {  
int end = start+maxLength;  
if(end&gt;cs.length)  
end = cs.length;  
for(int i=start; i&lt;start+maxLength; i++) {  
if(cs\[i]==util) {  
return i-start+1;  
}  
}  
return (-1);  
}

// compare standard tag "&lt;input" with tag "&lt;INPUT value=aa&gt;"  
private boolean compareTag(final char\[] ori\_tag, char\[] tag) {  
if(ori\_tag.length&gt;=tag.length)  
return false;  
for(int i=0; i&lt;ori\_tag.length; i++) {  
if(Character.toLowerCase(tag\[i])!=ori\_tag\[i])  
return false;  
}  
// the following char should not be a-z:  
if(tag.length&gt;ori\_tag.length) {  
char c = Character.toLowerCase(tag\[ori\_tag.length]);  
if(c&lt;'a' || c&gt;'z')  
return true;  
return false;  
}  
return true;  
}

private boolean compareString(final char\[] ori, char\[] comp) {  
if(ori.length&gt;comp.length)  
return false;  
for(int i=0; i&lt;ori.length; i++) {  
if(Character.toLowerCase(comp\[i])!=ori\[i])  
return false;  
}  
return true;  
}

public String toString() {  
return html;  
}  
}

注意，请先将html中的&lt;body&gt;...&lt;/body&gt;部分提取出来，再交给WebFormatter处理，因为html-&gt;text转换实质是删除所有标签（某些标签如&lt;br&gt;被转化为'\\n'）、Script和注释，对于JavaScript生成的动态内容（例如document.write）无能为力。