Usuń tagi HTML z łańcucha

Czy istnieje dobry sposób na usunięcie HTML z ciągu Java? Proste wyrażenie regularne

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

będzie działać, ale rzeczy takie jak &nie będą poprawnie konwertowane, a nie HTML między dwoma nawiasami kątowymi zostanie usunięty (tj. .*?w wyrażeniu regularnym zniknie).

Użyj parsera HTML zamiast wyrażenia regularnego. To jest bardzo proste z Jsoup .

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

Jsoup również wspiera usuwanie tagów HTML przeciwko konfigurowalny białej listy, co jest bardzo przydatne, jeśli chcesz zezwolić tylko przykład <b>, <i>i <u>.

Zobacz też:

• RegEx dopasowuje otwarte tagi z wyjątkiem tagów niezależnych XHTML
• Jakie są zalety i wady wiodących parserów Java HTML?
• Zapobieganie XSS w aplikacji internetowej JSP / Servlet

Jeśli piszesz dla Androida, możesz to zrobić ...

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

Jeśli użytkownik wejdzie <b>hey!</b>, czy chcesz wyświetlić <b>hey!</b>lub hey!? Jeśli pierwszy, uciekaj mniej niż, i kodowania html ampersands (i opcjonalnie cytuje) i wszystko w porządku. Modyfikacja kodu w celu wdrożenia drugiej opcji to:

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

ale napotkasz problemy, jeśli użytkownik wpisze coś zniekształconego, na przykład <bhey!</b>.

Możesz także sprawdzić JTidy, który przeanalizuje „brudne” dane HTML i powinien dać ci sposób na usunięcie tagów, zachowując tekst.

Problem z próbą usuwania html polega na tym, że przeglądarki mają bardzo łagodny parser, bardziej łagodny niż jakakolwiek biblioteka, którą można znaleźć, więc nawet jeśli zrobisz wszystko, aby usunąć wszystkie tagi (używając powyższej metody zastępowania, biblioteki DOM lub JTidy) , nadal musisz zakodować wszystkie pozostałe znaki specjalne HTML, aby zachować bezpieczeństwo wyników.

Innym sposobem jest użycie javax.swing.text.html.HTMLEditorKit do wyodrębnienia tekstu.

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: Usuń tagi HTML z pliku, aby wyodrębnić tylko TEKST

Myślę, że najprostszym sposobem filtrowania tagów HTML jest:

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

Również bardzo proste przy użyciu Jericho , i możesz zachować część formatowania (na przykład podziały wierszy i łącza).

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

Akceptowana odpowiedź zrobienia Jsoup.parse(html).text()ma po prostu 2 potencjalne problemy (z JSoup 1.7.3):

• Usuwa podziały linii z tekstu
• Konwertuje tekst <script>na<script>

Jeśli użyjesz tego do ochrony przed XSS, będzie to trochę denerwujące. Oto mój najlepszy strzał na ulepszone rozwiązanie, używając zarówno JSoup, jak i 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);

Zauważ, że ostatnim krokiem jest to, że muszę użyć danych wyjściowych jako zwykłego tekstu. Jeśli potrzebujesz tylko danych wyjściowych HTML, powinieneś być w stanie je usunąć.

A oto kilka przypadków testowych (dane wejściowe do danych wyjściowych):

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

Jeśli znajdziesz sposób na ulepszenie, daj mi znać.

Na Androidzie spróbuj:

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

Ucieczka HTML jest naprawdę trudna do zrobienia - zdecydowanie sugerowałbym użycie do tego kodu bibliotecznego, ponieważ jest o wiele bardziej subtelny, niż mogłoby się wydawać. Sprawdź StringEscapeUtils Apache'a, aby znaleźć całkiem dobrą bibliotekę do obsługi tego w Javie.

To powinno działać -

Użyj tego

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

i to

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

Być może zechcesz zastąpić <br/>i </p>otagować nowymi liniami przed usunięciem HTML, aby nie stał się nieczytelnym bałaganem, jak sugeruje Tim.

Jedynym sposobem, w jaki mogę wymyślić usunięcie tagów HTML, ale pozostawienie kodu innego niż HTML między nawiasami kątowymi, byłoby sprawdzenie na liście tagów HTML . Coś w tym stylu ...

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

Następnie odkoduj znaki specjalne HTML, takie jak &. Wynik nie powinien być uważany za zdezynfekowany.

Alternatywnie można użyć HtmlCleaner :

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

Przyjęta odpowiedź nie zadziałała dla wskazanego przeze mnie przypadku testowego: wynikiem „a <b lub b> c” jest „ab lub b> c”.

Więc zamiast tego użyłem TagSoup. Oto ujęcie, które zadziałało w moim przypadku testowym (i kilku innych):

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

Wiem, że to stare, ale właśnie pracowałem nad projektem, który wymagał ode mnie filtrowania HTML i działało to dobrze:

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

zamiast tego:

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

Oto nieco bardziej rozbudowana aktualizacja, aby spróbować poradzić sobie z formatowaniem przerw i list. Użyłem wyników Amayi jako przewodnika.

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

Posługiwać się Html.fromHtml

Tagi HTML są

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

Zgodnie z oficjalnymi dokumentacjami Androida wszelkie tagi w HTML będą wyświetlane jako ogólny ciąg zastępczy, który następnie program może przejść i zastąpić prawdziwymi ciągami .

Html.formHtmlMetoda przyjmuje Html.TagHandlerjako argumenty argument Html.ImageGetter oraz tekst do analizy.

Przykład

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

Następnie

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

Wynik

To o mnie tekst, który użytkownik może umieścić w swoim profilu

Oto jeszcze jeden wariant sposobu zamiany wszystkich (Tagi HTML | Elementy HTML | Puste miejsce w treści HTML)

content.replaceAll("(<.*?>)|(&.*?;)|([ ]{2,})", ""); gdzie treść jest ciągiem.

Możesz po prostu użyć domyślnego filtra HTML Androida

    public String htmlToStringFilter(String textToFilter){

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

    }

Powyższa metoda zwróci filtrowany ciąg HTML do wprowadzenia.

Jeszcze jednym sposobem może być użycie klasy com.google.gdata.util.common.html.HtmlToText, np.

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

Nie jest to jednak kod kuloodporny, a kiedy uruchamiam go na pozycjach wikipedii, również otrzymuję informacje o stylu. Uważam jednak, że w przypadku małych / prostych prac byłoby to skuteczne.

Wygląda na to, że chcesz przejść z HTML do zwykłego tekstu.
Jeśli tak jest, spójrz na www.htmlparser.org. Oto przykład, który usuwa wszystkie tagi z pliku HTML znalezionego pod adresem URL.
Wykorzystuje org.htmlparser.beans.StringBean .

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

Oto inny sposób, aby to zrobić:

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

W tym celu można również użyć Apache Tika . Domyślnie zachowuje białe znaki z pozbawionego kodu HTML, co może być pożądane w niektórych sytuacjach:

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

Jednym ze sposobów zachowania informacji o nowej linii w JSoup jest poprzedzenie wszystkich nowych tagów linii jakimś fikcyjnym łańcuchem, wykonanie JSoup i zastąpienie fikcyjnego łańcucha "\ 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");

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

Moje 5 centów:

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

Aby uzyskać sformatowany zwykły tekst HTML, możesz to zrobić:

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

Aby uzyskać sformatowany zwykły tekst, zmień <br/> o \ n i zmień ostatni wiersz o:

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

Wiem, że minęło trochę czasu, odkąd zadano to pytanie, ale znalazłem inne rozwiązanie, oto, co zadziałało dla mnie:

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

możesz po prostu stworzyć metodę z wieloma podobnymi replaceAll ()

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

Użyj tego linku, aby znaleźć najczęściej potrzebne zamienniki: http://tunes.org/wiki/html_20special_20characters_20 i_20symbols.html

To proste, ale skuteczne. Najpierw używam tej metody do usuwania śmieci, ale nie do pierwszego wiersza, tj. ReplaceAll („\ <. *?>”, „”), A następnie używam określonych słów kluczowych do wyszukiwania indeksów, a następnie używam .substring (start, end ) metoda usuwania niepotrzebnych rzeczy. Ponieważ jest to bardziej niezawodne i możesz dokładnie wskazać, czego potrzebujesz na całej stronie HTML.

Usuń tagi HTML z łańcucha. Gdzieś musimy przeanalizować jakiś ciąg, który jest odbierany przez niektóre odpowiedzi, takie jak Httpresponse z serwera.

Więc musimy to przeanalizować.

Tutaj pokażę, jak usunąć tagi HTML z ciągu.

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