जावा में HTML कैरेक्टर एंटिसेप्स को कैसे हटाएं?

Question

मूल रूप से मैं किसी दिए गए Html दस्तावेज़ को डीकोड करना चाहूंगा, और सभी विशेष वर्णों को प्रतिस्थापित करूंगा, जैसे " "-> " ", ">"-> ">"।

.NET में हम इसका उपयोग कर सकते हैं HttpUtility.HtmlDecode।

जावा में समान कार्य क्या है?

Comments

& nbsp; चरित्र इकाई कहा जाता है। शीर्षक संपादित किया।

— यूजीन योकोटा

Answer 1

मैंने इसके लिए Apache Commons StringEscapeUtils.unescapeHtml4 () का उपयोग किया है :

एक स्ट्रिंग युक्त इकाई से बाहर निकलता है एक स्ट्रिंग से बचता है जिसमें वास्तविक यूनिकोड वर्ण होता है जो भागने के लिए होता है। HTML 4.0 संस्थाओं का समर्थन करता है।

Comments

दुर्भाग्य से मैं सिर्फ एहसास हुआ आज यह नहीं डिकोड HTMLspecial पात्रों बहुत अच्छी तरह से करता है कि :(

— सिड

एक गंदे चाल मूल्य को शुरू में बचने के लिए एक छिपे हुए क्षेत्र में संग्रहीत करना है, फिर लक्ष्य क्षेत्र को छिपे हुए क्षेत्र से मूल्य प्राप्त करना चाहिए।

— सेटज़ामोरा

क्लास StringEscapeUtils को खाली कर दिया गया है और अपाचे कॉमन्स-टेक्स्ट में

— पाउली

मैं स्ट्रिंग परिवर्तित करना चाहते <p>&uuml;&egrave;</p>करने के लिए <p>üé</p>, के साथ StringEscapeUtils.unescapeHtml4()मैं <p>üè</p>। क्या मौजूदा html टैग्स को बरकरार रखने का कोई तरीका है?

— निकर्क

Answer 2

अन्य उत्तरों में उल्लिखित पुस्तकालय ठीक समाधान होंगे, लेकिन यदि आप पहले से ही अपनी परियोजना में वास्तविक दुनिया HTML के माध्यम से खुदाई कर रहे हैं, तो Jsoupपरियोजना में "एम्परसैंड पाउंड एफएफएफएफ सेमीकोलन" चीजों को प्रबंधित करने की तुलना में बहुत अधिक है ।

// textValue: <p>This is a&nbsp;sample. \"Granny\" Smith &#8211;.<\/p>\r\n
// becomes this: This is a sample. "Granny" Smith –.
// with one line of code:
// Jsoup.parse(textValue).getText(); // for older versions of Jsoup
Jsoup.parse(textValue).text();

// Another possibility may be the static unescapeEntities method:
boolean strictMode = true;
String unescapedString = org.jsoup.parser.Parser.unescapeEntities(textValue, strictMode);

और आपको DOM, CSS, और jquery जैसी विधियों का सबसे अच्छा उपयोग करके डेटा निकालने और हेरफेर करने के लिए सुविधाजनक API भी मिलता है। यह ओपन सोर्स और MIT लाइसेंस है।

Comments

upvote +, लेकिन मुझे यह इंगित करना चाहिए कि Jsoup के नए संस्करण .text()इसके बजाय उपयोग करते हैं.getText()

— SourceVisor

शायद अधिक प्रत्यक्ष उपयोग करना है org.jsoup.parser.Parser.unescapeEntities(String string, boolean inAttribute)। एपीआई डॉक्स: jsoup.org/apidocs/org/jsoup/parser/…

— danneu

यह सही था, क्योंकि मैं पहले से ही अपने प्रोजेक्ट में Jsoup का उपयोग कर रहा हूं। इसके अलावा, @danneu सही था - Parser.unescapeEntities विज्ञापन के रूप में बिल्कुल काम करता है।

— मंडिस्सा डब्ल्यू

Answer 3

मैंने अपने प्रोजेक्ट में Apache Commons StringEscapeUtils.unescapeHtml3 () की कोशिश की, लेकिन अपने प्रदर्शन से संतुष्ट नहीं था। बाहर मुड़ता है, यह बहुत सारे अनावश्यक ऑपरेशन करता है। एक के लिए, यह हर कॉल के लिए एक स्ट्रिंगट्राइटर आवंटित करता है, भले ही स्ट्रिंग में कुछ भी न हो। मैंने उस कोड को अलग तरीके से लिखा है, अब यह बहुत तेजी से काम करता है। जो कोई भी इसे Google में पाता है उसका उपयोग करने के लिए स्वागत है।

निम्नलिखित कोड सभी HTML 3 प्रतीकों और संख्यात्मक एस्केप (Apache unescapeHtml3 के बराबर) को हटाता है। यदि आपको HTML 4 की आवश्यकता है तो आप मानचित्र में अधिक प्रविष्टियाँ जोड़ सकते हैं।

package com.example;

import java.io.StringWriter;
import java.util.HashMap;

public class StringUtils {

    public static final String unescapeHtml3(final String input) {
        StringWriter writer = null;
        int len = input.length();
        int i = 1;
        int st = 0;
        while (true) {
            // look for '&'
            while (i < len && input.charAt(i-1) != '&')
                i++;
            if (i >= len)
                break;

            // found '&', look for ';'
            int j = i;
            while (j < len && j < i + MAX_ESCAPE + 1 && input.charAt(j) != ';')
                j++;
            if (j == len || j < i + MIN_ESCAPE || j == i + MAX_ESCAPE + 1) {
                i++;
                continue;
            }

            // found escape 
            if (input.charAt(i) == '#') {
                // numeric escape
                int k = i + 1;
                int radix = 10;

                final char firstChar = input.charAt(k);
                if (firstChar == 'x' || firstChar == 'X') {
                    k++;
                    radix = 16;
                }

                try {
                    int entityValue = Integer.parseInt(input.substring(k, j), radix);

                    if (writer == null) 
                        writer = new StringWriter(input.length());
                    writer.append(input.substring(st, i - 1));

                    if (entityValue > 0xFFFF) {
                        final char[] chrs = Character.toChars(entityValue);
                        writer.write(chrs[0]);
                        writer.write(chrs[1]);
                    } else {
                        writer.write(entityValue);
                    }

                } catch (NumberFormatException ex) { 
                    i++;
                    continue;
                }
            }
            else {
                // named escape
                CharSequence value = lookupMap.get(input.substring(i, j));
                if (value == null) {
                    i++;
                    continue;
                }

                if (writer == null) 
                    writer = new StringWriter(input.length());
                writer.append(input.substring(st, i - 1));

                writer.append(value);
            }

            // skip escape
            st = j + 1;
            i = st;
        }

        if (writer != null) {
            writer.append(input.substring(st, len));
            return writer.toString();
        }
        return input;
    }

    private static final String[][] ESCAPES = {
        {"\"",     "quot"}, // " - double-quote
        {"&",      "amp"}, // & - ampersand
        {"<",      "lt"}, // < - less-than
        {">",      "gt"}, // > - greater-than

        // Mapping to escape ISO-8859-1 characters to their named HTML 3.x equivalents.
        {"\u00A0", "nbsp"}, // non-breaking space
        {"\u00A1", "iexcl"}, // inverted exclamation mark
        {"\u00A2", "cent"}, // cent sign
        {"\u00A3", "pound"}, // pound sign
        {"\u00A4", "curren"}, // currency sign
        {"\u00A5", "yen"}, // yen sign = yuan sign
        {"\u00A6", "brvbar"}, // broken bar = broken vertical bar
        {"\u00A7", "sect"}, // section sign
        {"\u00A8", "uml"}, // diaeresis = spacing diaeresis
        {"\u00A9", "copy"}, // © - copyright sign
        {"\u00AA", "ordf"}, // feminine ordinal indicator
        {"\u00AB", "laquo"}, // left-pointing double angle quotation mark = left pointing guillemet
        {"\u00AC", "not"}, // not sign
        {"\u00AD", "shy"}, // soft hyphen = discretionary hyphen
        {"\u00AE", "reg"}, // ® - registered trademark sign
        {"\u00AF", "macr"}, // macron = spacing macron = overline = APL overbar
        {"\u00B0", "deg"}, // degree sign
        {"\u00B1", "plusmn"}, // plus-minus sign = plus-or-minus sign
        {"\u00B2", "sup2"}, // superscript two = superscript digit two = squared
        {"\u00B3", "sup3"}, // superscript three = superscript digit three = cubed
        {"\u00B4", "acute"}, // acute accent = spacing acute
        {"\u00B5", "micro"}, // micro sign
        {"\u00B6", "para"}, // pilcrow sign = paragraph sign
        {"\u00B7", "middot"}, // middle dot = Georgian comma = Greek middle dot
        {"\u00B8", "cedil"}, // cedilla = spacing cedilla
        {"\u00B9", "sup1"}, // superscript one = superscript digit one
        {"\u00BA", "ordm"}, // masculine ordinal indicator
        {"\u00BB", "raquo"}, // right-pointing double angle quotation mark = right pointing guillemet
        {"\u00BC", "frac14"}, // vulgar fraction one quarter = fraction one quarter
        {"\u00BD", "frac12"}, // vulgar fraction one half = fraction one half
        {"\u00BE", "frac34"}, // vulgar fraction three quarters = fraction three quarters
        {"\u00BF", "iquest"}, // inverted question mark = turned question mark
        {"\u00C0", "Agrave"}, // А - uppercase A, grave accent
        {"\u00C1", "Aacute"}, // Б - uppercase A, acute accent
        {"\u00C2", "Acirc"}, // В - uppercase A, circumflex accent
        {"\u00C3", "Atilde"}, // Г - uppercase A, tilde
        {"\u00C4", "Auml"}, // Д - uppercase A, umlaut
        {"\u00C5", "Aring"}, // Е - uppercase A, ring
        {"\u00C6", "AElig"}, // Ж - uppercase AE
        {"\u00C7", "Ccedil"}, // З - uppercase C, cedilla
        {"\u00C8", "Egrave"}, // И - uppercase E, grave accent
        {"\u00C9", "Eacute"}, // Й - uppercase E, acute accent
        {"\u00CA", "Ecirc"}, // К - uppercase E, circumflex accent
        {"\u00CB", "Euml"}, // Л - uppercase E, umlaut
        {"\u00CC", "Igrave"}, // М - uppercase I, grave accent
        {"\u00CD", "Iacute"}, // Н - uppercase I, acute accent
        {"\u00CE", "Icirc"}, // О - uppercase I, circumflex accent
        {"\u00CF", "Iuml"}, // П - uppercase I, umlaut
        {"\u00D0", "ETH"}, // Р - uppercase Eth, Icelandic
        {"\u00D1", "Ntilde"}, // С - uppercase N, tilde
        {"\u00D2", "Ograve"}, // Т - uppercase O, grave accent
        {"\u00D3", "Oacute"}, // У - uppercase O, acute accent
        {"\u00D4", "Ocirc"}, // Ф - uppercase O, circumflex accent
        {"\u00D5", "Otilde"}, // Х - uppercase O, tilde
        {"\u00D6", "Ouml"}, // Ц - uppercase O, umlaut
        {"\u00D7", "times"}, // multiplication sign
        {"\u00D8", "Oslash"}, // Ш - uppercase O, slash
        {"\u00D9", "Ugrave"}, // Щ - uppercase U, grave accent
        {"\u00DA", "Uacute"}, // Ъ - uppercase U, acute accent
        {"\u00DB", "Ucirc"}, // Ы - uppercase U, circumflex accent
        {"\u00DC", "Uuml"}, // Ь - uppercase U, umlaut
        {"\u00DD", "Yacute"}, // Э - uppercase Y, acute accent
        {"\u00DE", "THORN"}, // Ю - uppercase THORN, Icelandic
        {"\u00DF", "szlig"}, // Я - lowercase sharps, German
        {"\u00E0", "agrave"}, // а - lowercase a, grave accent
        {"\u00E1", "aacute"}, // б - lowercase a, acute accent
        {"\u00E2", "acirc"}, // в - lowercase a, circumflex accent
        {"\u00E3", "atilde"}, // г - lowercase a, tilde
        {"\u00E4", "auml"}, // д - lowercase a, umlaut
        {"\u00E5", "aring"}, // е - lowercase a, ring
        {"\u00E6", "aelig"}, // ж - lowercase ae
        {"\u00E7", "ccedil"}, // з - lowercase c, cedilla
        {"\u00E8", "egrave"}, // и - lowercase e, grave accent
        {"\u00E9", "eacute"}, // й - lowercase e, acute accent
        {"\u00EA", "ecirc"}, // к - lowercase e, circumflex accent
        {"\u00EB", "euml"}, // л - lowercase e, umlaut
        {"\u00EC", "igrave"}, // м - lowercase i, grave accent
        {"\u00ED", "iacute"}, // н - lowercase i, acute accent
        {"\u00EE", "icirc"}, // о - lowercase i, circumflex accent
        {"\u00EF", "iuml"}, // п - lowercase i, umlaut
        {"\u00F0", "eth"}, // р - lowercase eth, Icelandic
        {"\u00F1", "ntilde"}, // с - lowercase n, tilde
        {"\u00F2", "ograve"}, // т - lowercase o, grave accent
        {"\u00F3", "oacute"}, // у - lowercase o, acute accent
        {"\u00F4", "ocirc"}, // ф - lowercase o, circumflex accent
        {"\u00F5", "otilde"}, // х - lowercase o, tilde
        {"\u00F6", "ouml"}, // ц - lowercase o, umlaut
        {"\u00F7", "divide"}, // division sign
        {"\u00F8", "oslash"}, // ш - lowercase o, slash
        {"\u00F9", "ugrave"}, // щ - lowercase u, grave accent
        {"\u00FA", "uacute"}, // ъ - lowercase u, acute accent
        {"\u00FB", "ucirc"}, // ы - lowercase u, circumflex accent
        {"\u00FC", "uuml"}, // ь - lowercase u, umlaut
        {"\u00FD", "yacute"}, // э - lowercase y, acute accent
        {"\u00FE", "thorn"}, // ю - lowercase thorn, Icelandic
        {"\u00FF", "yuml"}, // я - lowercase y, umlaut
    };

    private static final int MIN_ESCAPE = 2;
    private static final int MAX_ESCAPE = 6;

    private static final HashMap<String, CharSequence> lookupMap;
    static {
        lookupMap = new HashMap<String, CharSequence>();
        for (final CharSequence[] seq : ESCAPES) 
            lookupMap.put(seq[1].toString(), seq[0]);
    }

}

Comments

हाल ही में, मुझे एक धीमी स्ट्रट्स परियोजना को अनुकूलित करना पड़ा। यह पता चला है कि कवर के तहत स्ट्रट्स डिफ़ॉल्ट रूप से ( <s:property value="..."/>) से बचने के लिए एचटीएमएल स्ट्रिंग के लिए अपाचे कहता है । भागने से बचना ( <s:property value="..." escaping="false"/>) कुछ पृष्ठों को 5% से 20% तेजी से चलाने के लिए मिला।

— Stephan

बाद में मुझे पता चला कि तर्क के रूप में खाली स्ट्रिंग दिए जाने पर यह कोड लूप में प्रवेश कर सकता है। वर्तमान संस्करण में वह समस्या ठीक हो गई है।

— निक फ्रलोव

क्या यह बचता है या अप्रकाशित होता है? & amp; डिकोड नहीं किया गया है। मानचित्र में केवल & जोड़ा जाता है, इसलिए यह केवल एक ही तरीके से काम करता है?

— एमएमएम

StringWriter आंतरिक रूप से StringBuffer का उपयोग करता है जो लॉकिंग का उपयोग करता है। सीधे स्ट्रिंग स्ट्रिंग का उपयोग करना तेज होना चाहिए।

— एक्सल डॉल्फलर

@NickFrolov, आपकी टिप्पणी कुछ गड़बड़ लगती है। aumlउदाहरण के लिए है äऔर नहीं д।

— aioobe

Answer 4

जावा में HTML भागने के लिए निम्न पुस्तकालय का भी उपयोग किया जा सकता है: unbescape ।

HTML को इस तरह से हटाया जा सकता है:

final String unescapedText = HtmlEscape.unescapeHtml(escapedText); 

Comments

इसने इसके लिए कुछ नहीं किया:%3Chtml%3E%0D%0A%3Chead%3E%0D%0A%3Ctitle%3Etest%3C%2Ftitle%3E%0D%0A%3C%2Fhead%3E%0D%0A%3Cbody%3E%0D%0Atest%0D%0A%3C%2Fbody%3E%0D%0A%3C%2Fhtml%3E

— थ्रोट

@ThreaT आपका टेक्स्ट html- एनकोडेड नहीं है, यह url-encoded है।

— मिखाइल बैटसर

Answer 5

इसने मेरे लिए काम किया,

import org.apache.commons.lang.StringEscapeUtils;
...
String decodedXML= StringEscapeUtils.unescapeHtml(encodedXML);

या

import org.apache.commons.lang3.StringEscapeUtils;
...
String decodedXML= StringEscapeUtils.unescapeHtml4(encodedXML);

मुझे लगता है कि यह हमेशा lang3स्पष्ट कारणों के लिए उपयोग करने के लिए बेहतर है । उम्मीद है की यह मदद करेगा :)

Answer 6

किसी भी बाहरी पुस्तकालय के बिना एक बहुत ही सरल लेकिन अक्षम समाधान है:

public static String unescapeHtml3( String str ) {
    try {
        HTMLDocument doc = new HTMLDocument();
        new HTMLEditorKit().read( new StringReader( "<html><body>" + str ), doc, 0 );
        return doc.getText( 1, doc.getLength() );
    } catch( Exception ex ) {
        return str;
    }
}

इसका उपयोग केवल तभी किया जाना चाहिए जब आपके पास डिकोड करने के लिए स्ट्रिंग की केवल छोटी संख्या हो।

Comments

बहुत करीब, लेकिन सटीक नहीं - इसने "qwAS12" "को" qwAS12 but \ n "में बदल दिया।

— ग्रेग

Answer 7

सबसे विश्वसनीय तरीका साथ है

String cleanedString = StringEscapeUtils.unescapeHtml4(originalString);

से org.apache.commons.lang3.StringEscapeUtils।

और व्हाट्सएप से बचने के लिए

cleanedString = cleanedString.trim();

यह सुनिश्चित करेगा कि वेब प्रपत्रों में कॉपी और पेस्ट के कारण व्हाट्सएप डीबी में स्थायी न हो।

Answer 8

स्प्रिंग फ्रेमवर्क HtmlUtils

यदि आप पहले से ही स्प्रिंग फ्रेमवर्क का उपयोग कर रहे हैं, तो निम्न विधि का उपयोग करें:

import static org.springframework.web.util.HtmlUtils.htmlUnescape;

...

String result = htmlUnescape(source);

Answer 9

HtmlManipulator जावा वर्ग का उपयोग करने पर विचार करें । आपको कुछ आइटम जोड़ने की आवश्यकता हो सकती है (सभी इकाइयां सूची में नहीं हैं)।

केविन हाकसन द्वारा सुझाए गए अपाचे कॉमन्स स्ट्रिंगरस्केप यूटिल्स ने मेरे लिए 100% काम नहीं किया; कई संस्थाओं जैसे & # 145 (एकल उद्धरण छोड़ दिया) का किसी भी तरह '222' में अनुवाद किया गया था। मैंने org.jsoup की भी कोशिश की, और वही समस्या थी।

Answer 10

मेरे मामले में मैं प्रत्येक चर में प्रत्येक इकाई का परीक्षण करके प्रतिस्थापित विधि का उपयोग करता हूं, मेरा कोड इस तरह दिखता है:

text = text.replace("Ç", "Ç");
text = text.replace("ç", "ç");
text = text.replace("Á", "Á");
text = text.replace("Â", "Â");
text = text.replace("Ã", "Ã");
text = text.replace("É", "É");
text = text.replace("Ê", "Ê");
text = text.replace("Í", "Í");
text = text.replace("Ô", "Ô");
text = text.replace("Õ", "Õ");
text = text.replace("Ó", "Ó");
text = text.replace("Ú", "Ú");
text = text.replace("á", "á");
text = text.replace("â", "â");
text = text.replace("ã", "ã");
text = text.replace("é", "é");
text = text.replace("ê", "ê");
text = text.replace("í", "í");
text = text.replace("ô", "ô");
text = text.replace("õ", "õ");
text = text.replace("ó", "ó");
text = text.replace("ú", "ú");

मेरे मामले में यह बहुत अच्छा था।

Comments

यह हर विशेष इकाई नहीं है। यहां तक कि दो प्रश्न में उल्लेख किया याद कर रहे हैं।

— सैंडी गिफोर्ड 2

यह अच्छी तरह से पैमाने पर नहीं होगा

— 4

Answer 11

आप की नकल क्या php समारोह htmlspecialchars_decode उपयोग php समारोह get_html_translation_table () तालिका डंप करने के लिए करता है और उसके बाद की तरह जावा कोड का उपयोग करना चाहते बैठाना,

static Map<String,String> html_specialchars_table = new Hashtable<String,String>();
static {
        html_specialchars_table.put("&lt;","<");
        html_specialchars_table.put("&gt;",">");
        html_specialchars_table.put("&amp;","&");
}
static String htmlspecialchars_decode_ENT_NOQUOTES(String s){
        Enumeration en = html_specialchars_table.keys();
        while(en.hasMoreElements()){
                String key = en.nextElement();
                String val = html_specialchars_table.get(key);
                s = s.replaceAll(key, val);
        }
        return s;
}

Comments

इतना मत डालो; उस HashMap पर जेनरिक का उपयोग करें! इसके अलावा, फ़ॉरचैट का उपयोग करें, न कि इसे पुनरावृत्त करने के लिए, कोड अधिक पठनीय लगेगा!

— WhyNotHugo

@ बालदत्त अगर आप अपने उत्तर को सुधारते हैं, तो लोग आपको अंक देंगे:

— स्पार्कसाइडर

अपने फ़ंक्शन और चर नामों को भी सुधारें, @ बाला।

— थॉमस डब्ल्यू