Entfernen Sie HTML-Tags aus einem String

Gibt es eine gute Möglichkeit, HTML aus einer Java-Zeichenfolge zu entfernen? Ein einfacher Regex wie

 replaceAll("\\<.*?>","") 

wird funktionieren, aber Dinge wie werden &nicht korrekt konvertiert und Nicht-HTML zwischen den beiden spitzen Klammern wird entfernt (dh die .*?in der Regex verschwinden).

Verwenden Sie einen HTML-Parser anstelle von Regex. Mit Jsoup ist das ganz einfach .

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

Jsoup auch unterstützt HTML - Tags gegen eine anpassbare weißen Liste zu entfernen, was sehr nützlich ist , wenn Sie zB zulassen möchten <b>, <i>und<u> .

Siehe auch:

• RegEx stimmt mit offenen Tags überein, mit Ausnahme von in sich geschlossenen XHTML-Tags
• Was sind die Vor- und Nachteile der führenden Java HTML-Parser?
• XSS-Prävention in der JSP / Servlet-Webanwendung

Wenn Sie für Android schreiben , können Sie dies tun ...

android.text.Html.fromHtml(instruction).toString()

Wenn der Benutzer eintritt <b>hey!</b>, möchten Sie anzeigen <b>hey!</b>oder hey!? Wenn dies der erste Fall ist, entkommen Sie weniger als und codieren kaufmännisches Und (und optional Anführungszeichen) in HTML, und es geht Ihnen gut. Eine Änderung an Ihrem Code zur Implementierung der zweiten Option wäre:

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

Sie werden jedoch auf Probleme stoßen, wenn der Benutzer etwas Falsches eingibt, wie z <bhey!</b>.

Sie können auch JTidy ausprobieren das "schmutzige" HTML-Eingaben analysiert und Ihnen eine Möglichkeit bietet, die Tags zu entfernen und den Text .

Das Problem beim Versuch, HTML zu entfernen, besteht darin, dass Browser sehr milde Parser haben, die milder sind als jede Bibliothek, die Sie finden können. Selbst wenn Sie Ihr Bestes tun, um alle Tags zu entfernen (mithilfe der obigen Ersetzungsmethode, einer DOM-Bibliothek oder JTidy) Sie müssen weiterhin sicherstellen, dass alle verbleibenden HTML-Sonderzeichen codiert sind, um Ihre Ausgabe sicher zu halten.

Eine andere Möglichkeit besteht darin , den Text mit javax.swing.text.html.HTMLEditorKit zu extrahieren.

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: Entfernen Sie HTML-Tags aus einer Datei, um nur den TEXT zu extrahieren

Ich denke, dass der einfachste Weg, die HTML-Tags zu filtern, ist:

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("");
}

Auch sehr einfach mit Jericho , und Sie können einige der Formatierungen beibehalten (z. B. Zeilenumbrüche und Links).

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

Die akzeptierte Antwort Jsoup.parse(html).text()hat einfach zwei mögliche Probleme (mit JSoup 1.7.3):

• Es entfernt Zeilenumbrüche aus dem Text
• Es konvertiert Text <script>in<script>

Wenn Sie dies zum Schutz vor XSS verwenden, ist dies etwas ärgerlich. Hier ist mein bester Versuch einer verbesserten Lösung mit JSoup und 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);

Beachten Sie, dass der letzte Schritt darin besteht, dass ich die Ausgabe als einfachen Text verwenden muss. Wenn Sie nur HTML-Ausgabe benötigen, sollten Sie diese entfernen können.

Und hier sind einige Testfälle (Eingabe zu Ausgabe):

{"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"}

Wenn Sie einen Weg finden, es besser zu machen, lassen Sie es mich bitte wissen.

Versuchen Sie dies auf Android:

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

HTML-Escaping ist wirklich schwer richtig zu machen - ich würde definitiv empfehlen, Bibliothekscode zu verwenden, da dies viel subtiler ist, als Sie denken. In StringEscapeUtils von Apache finden Sie eine ziemlich gute Bibliothek, um dies in Java zu handhaben.

Das sollte funktionieren -

benutze das

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

und das

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

Vielleicht möchten Sie ersetzen <br/>und</p> neue Zeilen Tags versehen, bevor Sie den HTML-Code entfernen, um zu verhindern, dass er unleserlich wird, wie Tim vorschlägt.

Die einzige Möglichkeit, HTML-Tags zu entfernen, aber Nicht-HTML in spitzen Klammern zu belassen, besteht darin, eine Liste von HTML-Tags zu verwenden . Etwas in diese Richtung ...

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

Dann HTML-decodieren Sonderzeichen wie &. Das Ergebnis sollte nicht als hygienisch angesehen werden.

Alternativ kann man HtmlCleaner verwenden :

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

Die akzeptierte Antwort funktionierte für mich für den von mir angegebenen Testfall nicht: Das Ergebnis von "a <b oder b> c" ist "ab oder b> c".

Also habe ich stattdessen TagSoup verwendet. Hier ist eine Aufnahme, die für meinen Testfall (und einige andere) funktioniert hat:

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 {
}
}

Ich weiß, dass dies alt ist, aber ich habe gerade an einem Projekt gearbeitet, bei dem ich HTML filtern musste, und das hat gut funktioniert:

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

an Stelle von:

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

Hier ist ein etwas ausführlicheres Update, um zu versuchen, einige Formatierungen für Pausen und Listen vorzunehmen. Ich habe Amayas Ausgabe als Leitfaden verwendet.

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));
    }
}

Verwenden Html.fromHtml

HTML- Tags sind

<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>

Gemäß offiziellen Dokumentationen Android keine Tags im HTML wird als generischer Ersatz angezeigt String , die das Programm dann durch und ersetzen mit echten gehen können Strings .

Html.formHtmlDie Methode verwendet ein Html.TagHandlerund ein Html.ImageGetter als Argumente sowie den zu analysierenden Text.

Beispiel

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

Dann

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

Ausgabe

Hier geht es um mich Text, den der Benutzer in sein Profil einfügen kann

Hier ist eine weitere Variante, wie alle ersetzt werden können (HTML-Tags | HTML-Entitäten | Leerraum in HTML-Inhalten).

content.replaceAll("(<.*?>)|(&.*?;)|([ ]{2,})", ""); Dabei ist der Inhalt ein String.

Sie können einfach den Standard-HTML-Filter von Android verwenden

    public String htmlToStringFilter(String textToFilter){

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

    }

Die obige Methode gibt die HTML-gefilterte Zeichenfolge für Ihre Eingabe zurück.

Eine weitere Möglichkeit kann darin bestehen, die Klasse com.google.gdata.util.common.html.HtmlToText wie zu verwenden

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

Dies ist jedoch kein kugelsicherer Code, und wenn ich ihn auf Wikipedia-Einträgen ausführe, erhalte ich auch Stilinformationen. Ich glaube jedoch, dass dies für kleine / einfache Jobs effektiv wäre.

Es hört sich so an, als ob Sie von HTML zu einfachem Text wechseln möchten.
Wenn dies der Fall ist, schauen Sie auf www.htmlparser.org. In diesem Beispiel werden alle Tags aus der HTML-Datei entfernt, die unter einer URL gefunden wurde.
Es verwendet org.htmlparser.beans.StringBean .

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

Hier ist eine andere Möglichkeit:

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;
}

Zu diesem Zweck könnte man auch Apache Tika verwenden. Standardmäßig werden Leerzeichen aus dem entfernten HTML-Code beibehalten, was in bestimmten Situationen erwünscht sein kann:

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

Eine Möglichkeit, neue Zeileninformationen mit JSoup beizubehalten, besteht darin, allen neuen Zeilen-Tags eine Dummy-Zeichenfolge voranzustellen, JSoup auszuführen und die Dummy-Zeichenfolge durch "\ n" zu ersetzen.

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");

Meine 5 Cent:

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);
}

Um formatierten einfachen HTML-Text zu erhalten , können Sie Folgendes tun:

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/>");

Um formatierten Klartext zu erhalten, ändern Sie <br/> um \ n und die letzte Zeile um:

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

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

Ich weiß, dass es eine Weile her ist, seit diese Frage gestellt wurde, aber ich habe eine andere Lösung gefunden. Das hat bei mir funktioniert:

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

Sie können einfach eine Methode mit mehreren replaceAll () wie erstellen

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

Verwenden Sie diesen Link für die häufigsten Ersetzungen, die Sie benötigen: http://tunes.org/wiki/html_20special_20characters_20and_20symbols.html

Es ist einfach aber effektiv. Ich benutze diese Methode zuerst, um den Müll zu entfernen, aber nicht die allererste Zeile, dh replaceAll ("\ <. *?>", ""), Und später verwende ich bestimmte Schlüsselwörter, um nach Indizes zu suchen, und verwende dann .substring (start, end ) Methode, um unnötiges Zeug zu entfernen. Da dies robuster ist und Sie genau das bestimmen können, was Sie auf der gesamten HTML-Seite benötigen.

Entfernen Sie HTML-Tags aus der Zeichenfolge. Irgendwo müssen wir eine Zeichenfolge analysieren, die von einigen Antworten wie Httpresponse vom Server empfangen wird.

Also müssen wir es analysieren.

Hier werde ich zeigen, wie man HTML-Tags aus dem String entfernt.

    // 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