从字符串中删除HTML标签

如果用户输入<b>hey!</b>，你想显示<b>hey!</b>还是hey!?如果是第一个，转义小于号和html编码的&号(可选的还有引号)，就没问题了。对代码进行修改以实现第二个选项将是:

replaceAll("\\<[^>]*>","")

但是如果用户输入一些不正常的东西，比如<bhey!</b>，你就会遇到问题。

你也可以检查JTidy，它将解析“脏”html输入，并应该给你一种方法来删除标签，保留文本。

尝试剥离html的问题是，浏览器有非常宽大的解析器，比你能找到的任何库都要宽大，所以即使你尽最大努力剥离所有标记(使用上面的替换方法，DOM库或JTidy)，你将仍然需要确保编码任何剩余的html特殊字符，以保证输出的安全。

HTML转义真的很难做对-我绝对建议使用库代码来做这件事，因为它比你想象的要微妙得多。在Apache的StringEscapeUtils中有一个很好的库，可以在Java中处理这个问题。

你可能想要在剥离HTML之前用换行符替换<br/>和</p>标记，以防止它像Tim建议的那样变得难以识别。

我能想到的唯一方法是删除HTML标记，但在尖括号之间留下非HTML，将检查HTML标签列表。沿着这条线……

replaceAll("\\<[\s]*tag[^>]*>","")

然后html解码特殊字符，如&。结果不应该被认为是消毒的。

static public String getUrlContentsAsText(String url) {
String content = "";
StringBean stringBean = new StringBean();
stringBean.setURL(url);
content = stringBean.getStrings();
return content;
}

另一种方法是使用javax.swing.text.html.HTMLEditorKit来提取文本。

import java.io.*;
import javax.swing.text.html.*;
import javax.swing.text.html.parser.*;


public class Html2Text extends HTMLEditorKit.ParserCallback {
StringBuffer s;


public Html2Text() {
}


public void parse(Reader in) throws IOException {
s = new StringBuffer();
ParserDelegator delegator = new ParserDelegator();
// the third parameter is TRUE to ignore charset directive
delegator.parse(in, this, Boolean.TRUE);
}


public void handleText(char[] text, int pos) {
s.append(text);
}


public String getText() {
return s.toString();
}


public static void main(String[] args) {
try {
// the HTML to convert
FileReader in = new FileReader("java-new.html");
Html2Text parser = new Html2Text();
parser.parse(in);
in.close();
System.out.println(parser.getText());
} catch (Exception e) {
e.printStackTrace();
}
}
}

ref: 从文件中删除HTML标记以只提取TEXT

这里有一个稍微更充实的更新，试图处理一些格式的休息和列表。我用Amaya的输出作为指导。

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.Stack;
import java.util.logging.Logger;


import javax.swing.text.MutableAttributeSet;
import javax.swing.text.html.HTML;
import javax.swing.text.html.HTMLEditorKit;
import javax.swing.text.html.parser.ParserDelegator;


public class HTML2Text extends HTMLEditorKit.ParserCallback {
private static final Logger log = Logger
.getLogger(Logger.GLOBAL_LOGGER_NAME);


private StringBuffer stringBuffer;


private Stack<IndexType> indentStack;


public static class IndexType {
public String type;
public int counter; // used for ordered lists


public IndexType(String type) {
this.type = type;
counter = 0;
}
}


public HTML2Text() {
stringBuffer = new StringBuffer();
indentStack = new Stack<IndexType>();
}


public static String convert(String html) {
HTML2Text parser = new HTML2Text();
Reader in = new StringReader(html);
try {
// the HTML to convert
parser.parse(in);
} catch (Exception e) {
log.severe(e.getMessage());
} finally {
try {
in.close();
} catch (IOException ioe) {
// this should never happen
}
}
return parser.getText();
}


public void parse(Reader in) throws IOException {
ParserDelegator delegator = new ParserDelegator();
// the third parameter is TRUE to ignore charset directive
delegator.parse(in, this, Boolean.TRUE);
}


public void handleStartTag(HTML.Tag t, MutableAttributeSet a, int pos) {
log.info("StartTag:" + t.toString());
if (t.toString().equals("p")) {
if (stringBuffer.length() > 0
&& !stringBuffer.substring(stringBuffer.length() - 1)
.equals("\n")) {
newLine();
}
newLine();
} else if (t.toString().equals("ol")) {
indentStack.push(new IndexType("ol"));
newLine();
} else if (t.toString().equals("ul")) {
indentStack.push(new IndexType("ul"));
newLine();
} else if (t.toString().equals("li")) {
IndexType parent = indentStack.peek();
if (parent.type.equals("ol")) {
String numberString = "" + (++parent.counter) + ".";
stringBuffer.append(numberString);
for (int i = 0; i < (4 - numberString.length()); i++) {
stringBuffer.append(" ");
}
} else {
stringBuffer.append("*   ");
}
indentStack.push(new IndexType("li"));
} else if (t.toString().equals("dl")) {
newLine();
} else if (t.toString().equals("dt")) {
newLine();
} else if (t.toString().equals("dd")) {
indentStack.push(new IndexType("dd"));
newLine();
}
}


private void newLine() {
stringBuffer.append("\n");
for (int i = 0; i < indentStack.size(); i++) {
stringBuffer.append("    ");
}
}


public void handleEndTag(HTML.Tag t, int pos) {
log.info("EndTag:" + t.toString());
if (t.toString().equals("p")) {
newLine();
} else if (t.toString().equals("ol")) {
indentStack.pop();
;
newLine();
} else if (t.toString().equals("ul")) {
indentStack.pop();
;
newLine();
} else if (t.toString().equals("li")) {
indentStack.pop();
;
newLine();
} else if (t.toString().equals("dd")) {
indentStack.pop();
;
}
}


public void handleSimpleTag(HTML.Tag t, MutableAttributeSet a, int pos) {
log.info("SimpleTag:" + t.toString());
if (t.toString().equals("br")) {
newLine();
}
}


public void handleText(char[] text, int pos) {
log.info("Text:" + new String(text));
stringBuffer.append(text);
}


public String getText() {
return stringBuffer.toString();
}


public static void main(String args[]) {
String html = "<html><body><p>paragraph at start</p>hello<br />What is happening?<p>this is a<br />mutiline paragraph</p><ol>  <li>This</li>  <li>is</li>  <li>an</li>  <li>ordered</li>  <li>list    <p>with</p>    <ul>      <li>another</li>      <li>list        <dl>          <dt>This</dt>          <dt>is</dt>            <dd>sdasd</dd>            <dd>sdasda</dd>            <dd>asda              <p>aasdas</p>            </dd>            <dd>sdada</dd>          <dt>fsdfsdfsd</dt>        </dl>        <dl>          <dt>vbcvcvbcvb</dt>          <dt>cvbcvbc</dt>            <dd>vbcbcvbcvb</dd>          <dt>cvbcv</dt>          <dt></dt>        </dl>        <dl>          <dt></dt>        </dl></li>      <li>cool</li>    </ul>    <p>stuff</p>  </li>  <li>cool</li></ol><p></p></body></html>";
System.out.println(convert(html));
}
}

使用HTML解析器而不是正则表达式。这对于Jsoup来说非常简单。

public static String html2text(String html) {
return Jsoup.parse(html).text();
}

Jsoup还支持根据可定制的白名单删除HTML标签，如果你只想允许例如<b>， <i>和<u>，这是非常有用的。

参见:

• 除XHTML自含标签外的RegEx匹配打开标签
• 领先的Java HTML解析器的优点和缺点是什么?< / >
• JSP/Servlet web应用程序中的跨站防御

MyWriter.toConsole(HtmlToText.htmlToPlainText(htmlResponse));

虽然这不是防弹代码，但当我在维基百科条目上运行它时，我也得到了风格信息。然而，我相信对于小/简单的工作，这将是有效的。

对于我所指出的测试用例，接受的答案并不适用:“a <B or B > c”是“a B or B > c”。

所以，我用TagSoup代替。下面是一个对我的测试用例(以及其他一些测试用例)有效的示例:

import java.io.IOException;
import java.io.StringReader;
import java.util.logging.Logger;


import org.ccil.cowan.tagsoup.Parser;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;


/**
* Take HTML and give back the text part while dropping the HTML tags.
*
* There is some risk that using TagSoup means we'll permute non-HTML text.
* However, it seems to work the best so far in test cases.
*
* @author dan
* @see <a href="http://home.ccil.org/~cowan/XML/tagsoup/">TagSoup</a>
*/
public class Html2Text2 implements ContentHandler {
private StringBuffer sb;


public Html2Text2() {
}


public void parse(String str) throws IOException, SAXException {
XMLReader reader = new Parser();
reader.setContentHandler(this);
sb = new StringBuffer();
reader.parse(new InputSource(new StringReader(str)));
}


public String getText() {
return sb.toString();
}


@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
for (int idx = 0; idx < length; idx++) {
sb.append(ch[idx+start]);
}
}


@Override
public void ignorableWhitespace(char[] ch, int start, int length)
throws SAXException {
sb.append(ch);
}


// The methods below do not contribute to the text
@Override
public void endDocument() throws SAXException {
}


@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
}


@Override
public void endPrefixMapping(String prefix) throws SAXException {
}




@Override
public void processingInstruction(String target, String data)
throws SAXException {
}


@Override
public void setDocumentLocator(Locator locator) {
}


@Override
public void skippedEntity(String name) throws SAXException {
}


@Override
public void startDocument() throws SAXException {
}


@Override
public void startElement(String uri, String localName, String qName,
Attributes atts) throws SAXException {
}


@Override
public void startPrefixMapping(String prefix, String uri)
throws SAXException {
}
}

我认为过滤html标签最简单的方法是:

private static final Pattern REMOVE_TAGS = Pattern.compile("<.+?>");


public static String removeTags(String string) {
if (string == null || string.length() == 0) {
return string;
}


Matcher m = REMOVE_TAGS.matcher(string);
return m.replaceAll("");
}

你可以简单地用多个replaceAll()方法像

String RemoveTag(String html){
html = html.replaceAll("\\<.*?>","")
html = html.replaceAll("&nbsp;","");
html = html.replaceAll("&amp;"."");
----------
----------
return html;
}

使用此链接为您需要的最常见的替换: http://tunes.org/wiki/html_20special_20characters_20and_20symbols.html < / p >

这很简单，但很有效。我使用这个方法首先删除垃圾，但不是第一行，即replaceAll(“\<.*?>”，“”)，然后我使用特定的关键字搜索索引，然后使用.substring(开始，结束)方法剥离不必要的东西。因为这更健壮，你可以在整个html页面中准确地指出你需要什么。

我知道这是旧的，但我只是在一个项目，需要我过滤HTML，这工作得很好:

noHTMLString.replaceAll("\\&.*?\\;", "");

而不是这样:

html = html.replaceAll(" ","");
html = html.replaceAll("&"."");

如果你正在为安卓编写代码，你可以这样做…

androidx.core.text.HtmlCompat.fromHtml(指令,HtmlCompat.FROM_HTML_MODE_LEGACY) .toString ()

使用耶利哥也很简单，你可以保留一些格式(例如换行符和链接)。

    Source htmlSource = new Source(htmlText);
Segment htmlSeg = new Segment(htmlSource, 0, htmlSource.length());
Renderer htmlRend = new Renderer(htmlSeg);
System.out.println(htmlRend.toString());

我的5美分:

String[] temp = yourString.split("&");
String tmp = "";
if (temp.length > 1) {


for (int i = 0; i < temp.length; i++) {
tmp += temp[i] + "&";
}
yourString = tmp.substring(0, tmp.length() - 1);
}

这里有另一种方法:

public static String removeHTML(String input) {
int i = 0;
String[] str = input.split("");


String s = "";
boolean inTag = false;


for (i = input.indexOf("<"); i < input.indexOf(">"); i++) {
inTag = true;
}
if (!inTag) {
for (i = 0; i < str.length; i++) {
s = s + str[i];
}
}
return s;
}

也可以使用Apache Tika来实现这个目的。默认情况下，它保留了被剥离的html中的空白，这在某些情况下可能是需要的:

InputStream htmlInputStream = ..
HtmlParser htmlParser = new HtmlParser();
HtmlContentHandler htmlContentHandler = new HtmlContentHandler();
htmlParser.parse(htmlInputStream, htmlContentHandler, new Metadata())
System.out.println(htmlContentHandler.getBodyText().trim())

要获得格式化的纯HTML文本，你可以这样做:

String BR_ESCAPED = "<br/>";
Element el=Jsoup.parse(html).select("body");
el.select("br").append(BR_ESCAPED);
el.select("p").append(BR_ESCAPED+BR_ESCAPED);
el.select("h1").append(BR_ESCAPED+BR_ESCAPED);
el.select("h2").append(BR_ESCAPED+BR_ESCAPED);
el.select("h3").append(BR_ESCAPED+BR_ESCAPED);
el.select("h4").append(BR_ESCAPED+BR_ESCAPED);
el.select("h5").append(BR_ESCAPED+BR_ESCAPED);
String nodeValue=el.text();
nodeValue=nodeValue.replaceAll(BR_ESCAPED, "<br/>");
nodeValue=nodeValue.replaceAll("(\\s*<br[^>]*>){3,}", "<br/><br/>");

格式化的纯文本 change <br/>由\n和更改最后一行由:

nodeValue=nodeValue.replaceAll("(\\s*\n){3,}", "<br/><br/>");

或者，也可以使用HtmlCleaner:

private CharSequence removeHtmlFrom(String html) {
return new HtmlCleaner().clean(html).getText();
}

简单地做Jsoup.parse(html).text()的公认答案有两个潜在的问题(与JSoup 1.7.3):

• 它从文本中删除换行符
• 它将文本<script>转换为<script>

如果您使用它来防止XSS，这有点烦人。下面是我在一个改进的解决方案中最好的尝试，使用JSoup和Apache StringEscapeUtils:

// breaks multi-level of escaping, preventing &amp;lt;script&amp;gt; to be rendered as <script>
String replace = input.replace("&amp;", "");
// decode any encoded html, preventing &lt;script&gt; to be rendered as <script>
String html = StringEscapeUtils.unescapeHtml(replace);
// remove all html tags, but maintain line breaks
String clean = Jsoup.clean(html, "", Whitelist.none(), new Document.OutputSettings().prettyPrint(false));
// decode html again to convert character entities back into text
return StringEscapeUtils.unescapeHtml(clean);

注意，最后一步是因为我需要将输出作为纯文本使用。如果您只需要HTML输出，那么您应该能够删除它。

下面是一堆测试用例(从输入到输出):

{"regular string", "regular string"},
{"<a href=\"link\">A link</a>", "A link"},
{"<script src=\"http://evil.url.com\"/>", ""},
{"&lt;script&gt;", ""},
{"&amp;lt;script&amp;gt;", "lt;scriptgt;"}, // best effort
{"\" ' > < \n \\ é å à ü and & preserved", "\" ' > < \n \\ é å à ü and & preserved"}

如果你有办法让它变得更好，请告诉我。

从字符串中删除HTML标签。在某个地方，我们需要解析一些字符串，这些字符串是由服务器端的Httpresponse等响应接收到的。

所以我们需要解析它。

在这里，我将展示如何从字符串中删除html标签。

    // sample text with tags


string str = "<html><head>sdfkashf sdf</head><body>sdfasdf</body></html>";






// regex which match tags


System.Text.RegularExpressions.Regex rx = new System.Text.RegularExpressions.Regex("<[^>]*>");






// replace all matches with empty strin


str = rx.Replace(str, "");






//now str contains string without html tags

在Android上试试这个:

String result = Html.fromHtml(html).toString();

使用JSoup保留新行信息的一种方法是在所有新行标记之前使用一些虚拟字符串，执行JSoup并将虚拟字符串替换为“\n”。

String html = "<p>Line one</p><p>Line two</p>Line three<br/>etc.";
String NEW_LINE_MARK = "NEWLINESTART1234567890NEWLINEEND";
for (String tag: new String[]{"</p>","<br/>","</h1>","</h2>","</h3>","</h4>","</h5>","</h6>","</li>"}) {
html = html.replace(tag, NEW_LINE_MARK+tag);
}


String text = Jsoup.parse(html).text();


text = text.replace(NEW_LINE_MARK + " ", "\n\n");
text = text.replace(NEW_LINE_MARK, "\n\n");

使用Html.fromHtml

< em > < / HTML em >标签是

<a href=”…”> <b>,  <big>, <blockquote>, <br>, <cite>, <dfn>
<div align=”…”>,  <em>, <font size=”…” color=”…” face=”…”>
<h1>,  <h2>, <h3>, <h4>,  <h5>, <h6>
<i>, <p>, <small>
<strike>,  <strong>, <sub>, <sup>, <tt>, <u>

根据Android的官方文档， 超文本标记语言中的任何标记都将显示为通用的替换字符串，然后你的程序可以遍历并替换为真正的字符串< em > < / em >。

Html.formHtml方法接受一个Html.TagHandler和一个Html。ImageGetter作为参数以及要解析的文本。

例子

String Str_Html=" <p>This is about me text that the user can put into their profile</p> ";

然后

Your_TextView_Obj.setText(Html.fromHtml(Str_Html).toString());

输出

这是关于我的文本，用户可以放入他们的个人资料

〇应该可以

使用这个

  text.replaceAll('<.*?>' , " ") -> This will replace all the html tags with a space.

这

  text.replaceAll('&.*?;' , "")-> this will replace all the tags which starts with "&" and ends with ";" like  , &, > etc.

classeString.replaceAll("\\<(/?[^\\>]+)\\>", "\\ ").replaceAll("\\s+", " ").trim()

这里是如何替换所有(HTML标签| HTML实体|空白的HTML内容)的另一个变体

content.replaceAll("(<.*?>)|(&.*?;)|([ ]{2,})", "");，其中内容为字符串。

你可以简单地使用Android默认的HTML过滤器

    public String htmlToStringFilter(String textToFilter){


return Html.fromHtml(textToFilter).toString();


}

上面的方法将为您的输入返回经过HTML过滤的字符串。

我知道这个问题已经有一段时间没有被问到了，但我找到了另一个解决方案，这对我来说很有效:

Pattern REMOVE_TAGS = Pattern.compile("<.+?>");
Source source= new Source(htmlAsString);
Matcher m = REMOVE_TAGS.matcher(sourceStep.getTextExtractor().toString());
String clearedHtml= m.replaceAll("");

值得注意的是，如果你试图在服务栈项目中实现这一点，它已经是一个内置的字符串扩展

using ServiceStack.Text;
// ...
"The <b>quick</b> brown <p> fox </p> jumps over the lazy dog".StripHtml();

我经常发现我只需要去掉注释和脚本元素。这已经为我可靠地工作了15年，可以很容易地扩展到处理HTML或XML中的任何元素名称:

// delete all comments
response = response.replaceAll("<!--[^>]*-->", "");
// delete all script elements
response = response.replaceAll("<(script|SCRIPT)[^+]*?>[^>]*?<(/script|SCRIPT)>", "");

有时html字符串来自xml，带有这样的&lt. xml。在使用Jsoup时，我们需要解析它，然后清理它。

Document doc = Jsoup.parse(htmlstrl);
Whitelist wl = Whitelist.none();
String plain = Jsoup.clean(doc.text(), wl);

而仅使用Jsoup.parse(htmlstrl).text()不能删除标签。

试试javascript:

const strippedString = htmlString.replace(/(<([^>]+)>)/gi, "");
console.log(strippedString);

你可以使用这个方法从字符串中删除HTML标签，

public static String stripHtmlTags(String html) {


return html.replaceAll("<.*?>", "");


}

您可以使用此代码删除HTML标记，包括换行符。

function remove_html_tags(html) {
html = html.replace(/<div>/g, "").replace(/<\/div>/g, "<br>");
html = html.replace(/<br>/g, "$br$");
html = html.replace(/(?:\r\n|\r|\n)/g, '$br$');
var tmp = document.createElement("DIV");
tmp.innerHTML = html;
html = tmp.textContent || tmp.innerText;
html = html.replace(/\$br\$/g, "\n");
return html;
}