एक स्ट्रिंग से HTML टैग निकालें

Question

क्या जावा स्ट्रिंग से HTML हटाने का एक अच्छा तरीका है? एक साधारण रेगेक्स की तरह

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

काम करेगा, लेकिन &अभ्यस्त चीजों को सही ढंग से रूपांतरित किया जाएगा और दोनों कोण कोष्ठक के बीच गैर-एचटीएमएल हटा दिया जाएगा (यानी .*?रेगेक्स में गायब हो जाएगा)।

Comments

निम्नलिखित गाइड के साथ इसका उपयोग करें: संकलन 'org.jsoup: jsoup: 1.9.2'

— वाहिहोसिनी

stackoverflow.com/a/3149645/5733853

— वाहिदहोसिनी 19

इन्हें भी देखें: stackoverflow.com/a/21838532/363573

— Stephan

Answer 1

Regex के बजाय HTML parser का उपयोग करें। यह Jsoup के साथ मृत सरल है ।

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

Jsoup एक अनुकूलन योग्य श्वेतसूची के खिलाफ HTML टैग हटाने का भी समर्थन करता है , जो बहुत उपयोगी है यदि आप केवल उदाहरण के लिए अनुमति देना चाहते हैं <b>, <i>और <u>।

यह सभी देखें:

• RegEx, XHTML स्व-निहित टैग को छोड़कर खुले टैग से मेल खाता है
• अग्रणी जावा HTML पार्सर के पेशेवरों और विपक्ष क्या हैं?
• JSP / सर्वलेट वेब अनुप्रयोग में XSS की रोकथाम

Comments

Jsoup अच्छा है, लेकिन मुझे इसके साथ कुछ कमियों का सामना करना पड़ा। मैं इसे XSS से छुटकारा पाने के लिए उपयोग करता हूं, इसलिए मूल रूप से मुझे एक सादे पाठ इनपुट की उम्मीद है, लेकिन कुछ दुष्ट व्यक्ति मुझे कुछ HTML भेजने की कोशिश कर सकते हैं। Jsoup का उपयोग करते हुए, मैं सभी HTML को हटा सकता हूं, लेकिन दुर्भाग्य से यह एक के लिए कई रिक्त स्थान को

— सिकोड़ता है

@ निश्चित रूप से: इसके लिए आप Jsoup#clean()इसके बजाय उपयोग करना चाहते हैं ।

— बालूसी

स्वच्छ () का उपयोग करके अभी भी अतिरिक्त स्थान और \ n वर्ण हटा दिए जाएंगे। ex: Jsoup.clean ("a \ n b", Whitelist.none ()) "a b" लौटाता है

— कीथ

@Zeroows: यह बुरी तरह से विफल रहता है <p>Lorem ipsum 1 < 3 dolor sit amet</p>। फिर से, HTML एक नियमित भाषा नहीं है । यह पूरी तरह से मेरे से परे है क्यों हर कोई असली पार्सर का उपयोग करने के बजाय ब्याज के कुछ हिस्सों को पार्स करने के लिए उस पर रेगेक्स फेंकने की कोशिश करता रहता है।

— बालूसी

Jsoup.clean(unsafeString, "", Whitelist.none(), new OutputSettings().prettyPrint(false));

— लाइनब्रीक्स

Answer 2

यदि आप Android के लिए लिख रहे हैं तो आप ऐसा कर सकते हैं ...

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

Comments

बहुत बढ़िया टिप। :) यदि आप पाठ को टेक्स्ट दृश्य में प्रदर्शित कर रहे हैं, तो आप कुछ प्रारूपण को संरक्षित करने के लिए .toString () को भी छोड़ सकते हैं।

— लोर्ने लालटेते

@Branky यह मैंने कोशिश नहीं की है ... स्वीकृत जवाब आकर्षण की तरह काम करता है

— Maverick

बहुत अच्छा काम करता है। सभी html टैग स्ट्रिंग से हटा दिए गए थे।

— user3144836

यह अच्छा है, लेकिन <img> टैग को कुछ विचित्र चीजों से बदल दिया जाता है। मुझे छोटे वर्ग मिले जहां एक छवि थी

— बिबासवन बंद्योपाध्याय

@BibaswannBandyopadhyay एक अन्य उत्तर से इन पात्रों से छुटकारा पाने में मदद मिलती है

— विंस

Answer 3

यदि उपयोगकर्ता प्रवेश करता है <b>hey!</b>, तो क्या आप प्रदर्शित करना चाहते हैं <b>hey!</b>या hey!? यदि पहले, कम-से-कम, और html- एन्कोडेड एम्परसेंड्स (और वैकल्पिक रूप से उद्धरण) से बचें और आप ठीक हैं। दूसरा विकल्प लागू करने के लिए आपके कोड में संशोधन होगा:

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

लेकिन अगर उपयोगकर्ता कुछ विकृत, जैसे प्रवेश करता है तो आप मुद्दों पर चलेंगे <bhey!</b>।

आप JTidy को भी देख सकते हैं जो "गंदे" html इनपुट को पार्स कर देगा, और आपको पाठ को रखते हुए टैग हटाने का एक तरीका देना चाहिए।

Html को स्ट्रिप करने की कोशिश करने में समस्या यह है कि ब्राउज़रों के पास बहुत कम पार्सर्स होते हैं, किसी भी लाइब्रेरी की तुलना में अधिक उदार, जो आपको मिल सकती है, इसलिए भले ही आप सभी टैग्स को अलग करने की पूरी कोशिश करते हों (ऊपर दी गई विधि का उपयोग करके, DOM लाइब्रेरी या JTidy , आपको अभी भी अपने आउटपुट को सुरक्षित रखने के लिए किसी भी शेष HTML विशेष वर्णों को एनकोड करना सुनिश्चित करना होगा।

Comments

यदि आप HTML नोड सामग्री के अंदर <या> हस्ताक्षरित है, तो आप मुद्दों में भी चलते हैं। <span> मेरी आयु <टेक्स्ट का बहुत हिस्सा है> फिर आपकी आयु </ span> है। मुझे लगता है कि ऐसा करने के लिए केवल 100% तरीका कुछ XML DOM इंटरफ़ेस (जैसे SAX या समान) के माध्यम से है, नोड .getText () का उपयोग करने के लिए।

— मिता गुस्टिन

Answer 4

दूसरा तरीका 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 टैग्स को एक फाइल से निकालें

Comments

"ए <बी या बी> सी" का परिणाम "ए बी या बी> सी" है, जो दुर्भाग्यपूर्ण लगता है।

— dfrankow

यह मेरे लिए सबसे अच्छा काम किया। मुझे लाइन ब्रेक को संरक्षित करने की आवश्यकता थी। मैंने पार्सर में इस सरल विधि को जोड़कर किया: @Override public void handleStartTag (HTML.Tag t, MutableAttributeSet a, int pos) {if (t = HTML.Tag.P || t = - HTML.Tag.BR) {s.append ('\ n'); }}

— मिगेलमुनोज

dfrankow: गणितीय अभिव्यक्ति a <b या b> c को html में इस तरह लिखा जाना चाहिए: a & lt; b या b & gt; c

— मिगेलमुनोज

Answer 5

मुझे लगता है कि 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("");
}

Answer 6

जेरिको का उपयोग करके भी बहुत सरल है , और आप कुछ स्वरूपण (लाइन ब्रेक और लिंक, उदाहरण के लिए) को बनाए रख सकते हैं।

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

Comments

जैरिको एक लाइन ब्रेक के लिए <br> को पार्स करने में सक्षम थे। Jsoup और HTMLEditorKit ऐसा नहीं कर सका।

— होमएक्सो

जेरिको इस काम को करने में बहुत सक्षम है, स्वामित्व वाली परियोजनाओं में इसका बहुत उपयोग किया।

— जेरी तियान

जैरिको ने एक आकर्षण की तरह काम किया। सलाह के लिये धन्यवाद। एक नोट: आपको पूरे स्ट्रिंग का सेगमेंट बनाने की आवश्यकता नहीं है। स्रोत सेगमेंट का विस्तार करता है, इसलिए या तो रेंडरर कंस्ट्रक्टर में काम करता है।

— MrPlow

जेरिको अब थोड़ा दिनांकित लगता है (आखिरी रिलीज 2015 के अंत में 3.4 थी)। हालांकि, अगर यह अभी भी अच्छी तरह से काम करता है, तो यह अभी भी अच्छी तरह से काम करता है!

— जोनाथन हॉल्ट

Answer 7

बस करने के स्वीकृत उत्तर Jsoup.parse(html).text()में 2 संभावित मुद्दे हैं (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"}

यदि आपको इसे बेहतर बनाने का कोई तरीका मिल जाए, तो कृपया मुझे बताएं।

Comments

यह कुछ के खिलाफ असफल हो जाएगा <script>alert('Evil script executed');</script>। उसी के लिए जाता है &। JSoup परिवर्तित नहीं होता है &lt;script&gt; into <script>, ऐसा इसलिए होता है क्योंकि आप StringEscapeUtils.unescapeHtmlJSoup के इनपुट को साफ करने के बाद कॉल करते हैं।

— गिलाउम पोएट

Answer 8

Android पर, यह आज़माएँ:

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

Comments

यह यह किया! इसने टेक्स्ट से सभी इनलाइन html को हटा दिया :)

— DritanX

आप हमेशा सामान्य कोड के लिए कोड स्निपेट का उपयोग कर रहे हैं। कोड स्निपेट केवल HTML या जावास्क्रिप्ट या अन्य कोड के लिए उपयोग किया जाना चाहिए, जो ब्राउज़र में चलाया जा सकता है। आप ब्राउज़र में जावा नहीं चला सकते। भविष्य में सामान्य कोड ब्लॉक का उपयोग करें ... मैं इस बार आपके जवाब को संपादित करूंगा और फॉर्मेटिंग आदि को ठीक करूंगा, लेकिन कृपया भविष्य में ऐसा न करें। यह पहली बार नहीं है जब मैंने आपको इस बारे में बताया ...

— Xaver Kapeller

@PaulCroarkin यह android sdk के अंदर की लाइब्रेरी है। android.text.Html

— अमीन महेन

बहुत बढ़िया। सभी HTML टैग हटा दिए गए।

— user3144836

परिचित लग रहा है, 2011 से मेरे जवाब की तरह।

— केन गुडरिज

Answer 9

HTML एस्केपिंग वास्तव में सही करना मुश्किल है- मैं निश्चित रूप से ऐसा करने के लिए लाइब्रेरी कोड का उपयोग करने का सुझाव दूंगा, क्योंकि यह आपके विचार से बहुत अधिक सूक्ष्म है। जावा में इसे संभालने के लिए एक बहुत अच्छी लाइब्रेरी के लिए अपाचे के StringEscapeUtils को देखें।

Comments

यह उस तरह की चीज है जिसकी मैं तलाश कर रहा हूं लेकिन मैं इसे टालने के बजाय HTML स्ट्रिप करना चाहता हूं।

— मेसन

क्या आप html को स्ट्रिप करना चाहते हैं, या आप इसे प्लेन टेक्स्ट में बदलना चाहते हैं? Br टैग और HTML संस्थाओं के साथ एक लंबी स्ट्रिंग से HTML को स्ट्रिप करने के परिणामस्वरूप एक गैरकानूनी गड़बड़ हो सकती है।

— टिम हॉवेल

StringEscapeUtils.unescapeHtml html को स्ट्रिप नहीं करता है

— एरिन ड्रमंड बाद

बर्तनों पर अच्छी जानकारी के लिए उपयोग करने के लिए है, लेकिन सवाल का जवाब नहीं।

— एलेक्स

भ्रामक उत्तर। हटाना! = अनसुना करना

— मार्टिनेज

Answer 10

यह काम करना चाहिए -

इसे इस्तेमाल करो

  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.

Comments

आम तौर पर, उत्तर बहुत अधिक उपयोगी होते हैं यदि वे एक स्पष्टीकरण शामिल करते हैं कि कोड क्या करना है।

— पीटर

Answer 11

आप टिम को सुझाव देने के लिए HTML को अलग करने से पहले उसे नए रूप में बदलने <br/>और </p>टैग करने की अनुमति दे सकते हैं क्योंकि यह टिम के सुझाव के अनुसार एक गैरकानूनी गड़बड़ है।

जिस तरह से मैं HTML टैग को हटाने के बारे में सोच सकता हूं, लेकिन कोण कोष्ठक के बीच गैर-HTML को छोड़ने से HTML टैग की सूची के खिलाफ जांच होगी । इन पंक्तियों के साथ कुछ ...

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

फिर HTML- विशेष वर्णों को डीकोड करें &। परिणाम को स्वच्छता नहीं माना जाना चाहिए।

Answer 12

वैकल्पिक रूप से, कोई भी HtmlCleaner का उपयोग कर सकता है :

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

Comments

HtmlCleaner अच्छी तरह से काम करता है, लाइन ब्रेक रखता है और हाल ही में रिलीज़ हुआ है (मई 2017 में 2.21)।

— जोनाथन हॉल्ट

Answer 13

मेरे द्वारा दिए गए परीक्षण मामले के लिए स्वीकृत उत्तर मेरे लिए काम नहीं करता था: "ए <बी या बी> सी" का परिणाम "एब या बी> सी" है।

इसलिए, मैंने इसके बजाय 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 {
}
}

Answer 14

मुझे पता है कि यह पुराना है, लेकिन मैं सिर्फ एक प्रोजेक्ट पर काम कर रहा था जिसके लिए मुझे HTML फ़िल्टर करने की आवश्यकता थी और यह ठीक काम कर रहा था:

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

इसके अलावा:

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

Answer 15

यहाँ ब्रेक और सूचियों के लिए कुछ स्वरूपण को संभालने की कोशिश करने के लिए एक हल्का और अधिक fleshed अद्यतन है। मैंने एक गाइड के रूप में अमाया के आउटपुट का उपयोग किया।

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

Answer 16

उपयोग Html.fromHtml

HTML Tags हैं

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

के अनुसार एंड्रॉयड की आधिकारिक प्रलेखन में किसी भी टैग एचटीएमएल एक सामान्य स्थानापन्न के रूप में प्रदर्शित करेगा स्ट्रिंग जो अपने कार्यक्रम के माध्यम से जाना तो और वास्तविक से बदल सकते हैं तार ।

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

उत्पादन

यह मेरे बारे में पाठ है जो उपयोगकर्ता अपनी प्रोफ़ाइल में डाल सकता है

Comments

कोई अतिरिक्त उपयोगिताओं और Android डॉक्स के साथ संरेखित नहीं करता है। +1

— davidbates

Answer 17

यहाँ सभी को बदलने का एक और तरीका है (HTML Tags | HTML Entities | HTML सामग्री में रिक्त स्थान)

content.replaceAll("(<.*?>)|(&.*?;)|([ ]{2,})", ""); जहां सामग्री एक स्ट्रिंग है।

Comments

मैंने इसे थोड़ा सुधार दिया: {code} .replaceAll ("(<। *?>); | ((*।?;)", "") .ReplaceAll ("\\ s {2,}", "") { कोड} क्योंकि अक्सर वे टैग टेक्स्ट के बगल में होते हैं। और टैग हटाने के बाद सभी 2 और अधिक राइटस्पेस को केवल 1 में

— बदलें

Answer 18

आप बस एंड्रॉइड के डिफ़ॉल्ट HTML फ़िल्टर का उपयोग कर सकते हैं

    public String htmlToStringFilter(String textToFilter){

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

    }

उपरोक्त विधि आपके इनपुट के लिए HTML फ़िल्टर की गई स्ट्रिंग लौटाएगी।

Answer 19

एक और तरीका com.google.gdata.util.common.html.HtmlToText वर्ग का उपयोग करना हो सकता है

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

हालांकि यह बुलेट प्रूफ कोड नहीं है और जब मैं इसे विकिपीडिया प्रविष्टियों पर चलाता हूं तो मुझे स्टाइल की जानकारी भी मिल रही है। हालाँकि मेरा मानना ​​है कि छोटी / सरल नौकरियों के लिए यह प्रभावी होगा।

Answer 20

ऐसा लगता है कि आप सादे पाठ से HTML में जाना चाहते हैं।
अगर ऐसा है तो www.htmlparser.org पर देखें। यहां एक उदाहरण दिया गया है कि URL पर मिली html फ़ाइल से सभी टैग्स को हटा दिया गया है।
यह org.htmlparser.beans.StringBean का उपयोग करता है ।

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

Answer 21

यहाँ यह करने का एक और तरीका है:

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

Comments

या आप बस कह सकते हैं, अगर (input.indexOf ("<")> 0 || input.indexOf (">")> 0) वापसी ""; इनपुट वापस करें;

— होसैन शाहदोस्त

Answer 22

कोई इस उद्देश्य के लिए अपाचे टीका का उपयोग भी कर सकता है । डिफ़ॉल्ट रूप से यह हटाए गए HTML से व्हाट्सएप को संरक्षित करता है, जो कुछ स्थितियों में वांछित हो सकता है:

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

Comments

ध्यान दें कि पार्स विधि के पक्ष में पदावनत किया जाता है Parse.parse(InputStream, ContentHandler, Metadata, ParseContext)।

— जैकब वैन लिंगन

Answer 23

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

Answer 24

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

Comments

हालांकि यह कोड स्निपेट प्रश्न को हल कर सकता है, जिसमें स्पष्टीकरण सहित वास्तव में आपकी पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और उन लोगों को आपके कोड सुझाव के कारणों का पता नहीं चल सकता है। कृपया अपने कोड को व्याख्यात्मक टिप्पणियों के साथ भीड़ न दें, इससे कोड और स्पष्टीकरण दोनों की पठनीयता कम हो जाती है!

— फिल्नर

Answer 25

मेरे 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);
}

Answer 26

सादे सादे 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/>");

करने के लिए सादा पाठ formateed \ N द्वारा परिवर्तन <br/> और से अंतिम पंक्ति बदलने के लिए:

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

Answer 27

मुझे पता है कि इस सवाल के पूछे जाने के बाद से यह एक समय हो गया है, लेकिन मुझे एक और समाधान मिला है, यह मेरे लिए काम कर रहा है:

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

Answer 28

आप बस कई प्रतिस्थापन () की तरह एक विधि बना सकते हैं

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

यह सरल लेकिन प्रभावी है। मैं इस विधि का उपयोग पहले कबाड़ को हटाने के लिए करता हूं, लेकिन पहली पहली पंक्ति में नहीं है, अर्थात् प्रतिस्थापन ("\ <। *?>", ""), और बाद में मैं विशिष्ट कीवर्ड का उपयोग अनुक्रमित की खोज करने के लिए करता हूं और फिर .substring (प्रारंभ, अंत) का उपयोग करता हूं। ) अनावश्यक सामान को दूर करने की विधि। जैसा कि यह अधिक मजबूत है और आप पूरे HTML पृष्ठ में ठीक उसी बिंदु को इंगित कर सकते हैं जिसकी आपको आवश्यकता है।

Comments

दो नोट। सबसे पहले, यह सबऑप्टिमल है - प्रत्येक रिप्लेसमेंट कॉल के लिए, जावा एक रेगेक्स के रूप में पहले तर्क को संकलित करने का प्रयास करेगा और उस स्ट्रिंग में रेगेक्स को लागू करने के लिए पूरे स्ट्रिंग के माध्यम से चलाएगा, जो हर बार एक नियमित HTML पृष्ठ के लिए कुछ दर्जन KB प्रसंस्करण करता है। दूसरा, यह सलाह दी जाती है कि साधारण (नॉन-रेगेक्स) स्ट्रिंग्स को बदलने के लिए रिप्लेसमेंट का उपयोग न करें, बल्कि इसके बदले रिप्लेसमेंट () का भी इस्तेमाल करें (जो कि नाम के विपरीत सभी को बदल देता है)।

— 13

Answer 29

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

Comments

कहां new System.Text.RegularExpressions.Regex();से लाएं?

— beresfordt

@beresfordt यह प्रतिक्रिया .NET पर लागू होती है, न कि जावा की तरह प्रश्न में अनुरोध किया गया था

— एरिन ड्रमंड 2