जावा: किसी स्ट्रीम की सही चारसेट एन्कोडिंग का निर्धारण कैसे करें


140

निम्नलिखित सूत्र के संदर्भ में: जावा ऐप: iso-8859-1 एन्कोडेड फ़ाइल को सही ढंग से पढ़ने में असमर्थ

किसी इनपुटस्ट्रीम / फ़ाइल के सही चारसेट एन्कोडिंग को प्रोग्रामेटिक रूप से निर्धारित करने का सबसे अच्छा तरीका क्या है?

मैंने निम्नलिखित का उपयोग करने की कोशिश की है:

File in =  new File(args[0]);
InputStreamReader r = new InputStreamReader(new FileInputStream(in));
System.out.println(r.getEncoding());

लेकिन एक ऐसी फाइल पर जिसे मैं ISO8859_1 के साथ कूटबद्ध करना जानता हूं, उपरोक्त कोड ASCII की पैदावार है, जो सही नहीं है, और मुझे कंसोल के लिए फ़ाइल की सामग्री को सही ढंग से प्रस्तुत करने की अनुमति नहीं देता है।


11
एडुआर्ड सही है, "आप एक मनमाना बाइट स्ट्रीम के एन्कोडिंग को निर्धारित नहीं कर सकते हैं"। अन्य सभी प्रस्ताव आपको सर्वोत्तम अनुमान लगाने के तरीके (और पुस्तकालय) प्रदान करते हैं। लेकिन अंत में वे अभी भी अनुमान लगा रहे हैं।
मिहाई नीता

9
Reader.getEncodingएन्कोडिंग का रिटर्न रीडर का उपयोग करने के लिए सेट किया गया था, जो आपके मामले में डिफ़ॉल्ट एन्कोडिंग है।
करोल एस।

जवाबों:


70

मैंने इस लाइब्रेरी का उपयोग जावा में एन्कोडिंग का पता लगाने के लिए jchardet के समान किया है: http://code.google.com/p/juniversalchardet/


6
मैंने पाया कि यह अधिक सटीक था: jchardet.sourceforge.net (मैं पश्चिमी यूरोपीय भाषा के दस्तावेज़ों पर आईएसओ 8859-1, विंडोज़ -1252, यूटीएफ -8 में कूटबद्ध कर रहा था)
जोएल

1
यह juniversalchardet काम नहीं करता है। यह UTF-8 को अधिकांश समय बचाता है, भले ही फ़ाइल 100% विंडोज़ -1212 एन्कोडेड हो।
ब्रेन

1
जनिवर्सलचर्ड अब GitHub पर है
deamon को

यह पूर्वी यूरोपीय खिड़कियों -1250 का पता नहीं लगाता है
बर्नहार्ड डब्लर

मैंने " cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt " फ़ाइल से पता लगाने के लिए कोड स्निपेट का अनुसरण करने की कोशिश की, लेकिन पता चला वर्ण सेट के रूप में शून्य मिला। UniversalDetector ud = new UniversalDetector (नल); बाइट [] बाइट्स = FileUtils.readFileToByteArray (नई फ़ाइल (फ़ाइल)); ud.handleData (बाइट्स, 0, बाइट्स.लगाव); ud.dataEnd (); पता लगाया गया हैशर्त = ud.getDetectedCharset ();
रोहित वर्मा

105

आप एक मनमाने बाइट स्ट्रीम के एन्कोडिंग का निर्धारण नहीं कर सकते। यह एनकोडिंग की प्रकृति है। एन्कोडिंग का अर्थ है बाइट मान और उसके प्रतिनिधित्व के बीच एक मानचित्रण। इसलिए हर एन्कोडिंग "सही" हो सकती है।

GetEncoding () विधि एन्कोडिंग जो (पढ़ स्थापित किया गया था वापस आ जाएगी JavaDoc ) स्ट्रीम के लिए। यह आपके लिए एन्कोडिंग का अनुमान नहीं लगाएगा।

कुछ स्ट्रीम आपको बताती हैं कि उन्हें बनाने के लिए कौन सी एन्कोडिंग का उपयोग किया गया था: एक्सएमएल, एचटीएमएल। लेकिन एक मनमाना बाइट स्ट्रीम नहीं।

वैसे भी, आप अपने दम पर एक एन्कोडिंग का अनुमान लगाने की कोशिश कर सकते हैं यदि आपको करना है। हर भाषा में हर वर्ण के लिए एक सामान्य आवृत्ति होती है। अंग्रेजी में char e बहुत बार दिखाई देता है लेकिन ê बहुत ही कम दिखाई देगा। ISO-8859-1 स्ट्रीम में आमतौर पर 0x00 वर्ण नहीं होते हैं। लेकिन UTF-16 स्ट्रीम में उनमें से बहुत कुछ है।

या: आप उपयोगकर्ता से पूछ सकते हैं। मैंने पहले से ही ऐसे एप्लिकेशन देखे हैं जो आपको अलग-अलग एन्कोडिंग में फ़ाइल का एक स्निपेट पेश करते हैं और आपसे "सही" का चयन करने के लिए कहते हैं।


18
यह वास्तव में सवाल का जवाब नहीं देता है। ऑप शायद docs.codehaus.org/display/GUESSENC/Home या icu-project.org/apiref/icu4j/com/ibm/icu/text/… या jherhardet.sourceforge.net
Christoffer Hammarström

23
तो मेरे संपादक, नोटपैड ++ को कैसे पता है कि फ़ाइल को कैसे खोला जाए और मुझे सही पात्रों को कैसे दिखाया जाए?
mmm

12
@ हमीदाम यह भाग्य से है कि यह आपको सही चरित्र दिखाता है। जब यह गलत तरीके से अनुमान लगाता है (और यह अक्सर होता है), एक विकल्प है (मेनू >> एन्कोडिंग) जो आपको एन्कोडिंग को बदलने की अनुमति देता है।
पचेरियर

15
@ एडवर्ड: "तो हर एन्कोडिंग" "सही हो सकता है।" बिलकुल ठीक नहीं। कई टेक्स्ट एन्कोडिंग में कई पैटर्न होते हैं जो अमान्य हैं, जो कि एक ध्वज है जो पाठ संभवतः उस एन्कोडिंग नहीं है। वास्तव में, फ़ाइल के पहले दो बाइट्स को देखते हुए, केवल 38% संयोजन मान्य UTF8 हैं। संयोग से पहले 5 कोडपॉइंट्स का वैध UTF8 होने की संभावना .77% से कम है। इसी तरह, UTF16BE और LE को आमतौर पर बड़ी संख्या में शून्य बाइट्स द्वारा पहचाना जाता है और वे कहाँ हैं।
मूविंग डक

38

इसे देखें : http://site.icu-project.org/ (icu4j) IOStream से चारसेट का पता लगाने के लिए उनके पास पुस्तकालय हैं जो इस तरह सरल हो सकते हैं:

BufferedInputStream bis = new BufferedInputStream(input);
CharsetDetector cd = new CharsetDetector();
cd.setText(bis);
CharsetMatch cm = cd.detect();

if (cm != null) {
   reader = cm.getReader();
   charset = cm.getName();
}else {
   throw new UnsupportedCharsetException()
}

2
मैंने कोशिश की, लेकिन यह बहुत असफल रहा: मैंने ग्रहण में 2 पाठ फाइलें बनाईं जिसमें "öäü it" दोनों शामिल थे। एक iso एन्कोडिंग के लिए सेट और एक utf8 के लिए - दोनों utf8 के रूप में पाए जाते हैं! इसलिए मैंने अपने HD (विंडोज़) पर कहीं सुरक्षित एक फ़ाइल की कोशिश की - यह सही ढंग से पता चला था ("विंडोज़ -1252")। फिर मैंने एचडी पर दो नई फ़ाइल बनाईं जिनमें से एक को एडिटर ने दूसरे को नोटपैड ++ के साथ एडिट किया। दोनों मामलों में "Big5" (चीनी) का पता चला था!
dermoritz

2
संपादित करें: ठीक है, मुझे cm.getConfidence () की जाँच करनी चाहिए - मेरे छोटे "äöüß" आत्मविश्वास के साथ है। 10. इसलिए मुझे यह तय करना होगा कि क्या आत्मविश्वास काफी अच्छा है - लेकिन इस प्रयास के लिए
बिल्कुल

1
नमूना कोड का सीधा लिंक: userguide.icu-project.org/conversion/detection
james.garriss

27

यहाँ मेरे पसंदीदा हैं:

TikaEncodingDetector

निर्भरता:

<dependency>
  <groupId>org.apache.any23</groupId>
  <artifactId>apache-any23-encoding</artifactId>
  <version>1.1</version>
</dependency>

नमूना:

public static Charset guessCharset(InputStream is) throws IOException {
  return Charset.forName(new TikaEncodingDetector().guessEncoding(is));    
}

GuessEncoding

निर्भरता:

<dependency>
  <groupId>org.codehaus.guessencoding</groupId>
  <artifactId>guessencoding</artifactId>
  <version>1.4</version>
  <type>jar</type>
</dependency>

नमूना:

  public static Charset guessCharset2(File file) throws IOException {
    return CharsetToolkit.guessEncoding(file, 4096, StandardCharsets.UTF_8);
  }

2
नोट: TikaEncodingDetector 1.1 वास्तव में ICU4J 3.4 CharsetDectector वर्ग के आसपास एक पतला आवरण है ।
स्टीफन

दुर्भाग्य से दोनों काम नहीं करते हैं। एक मामले में यह एक यूएमएफ -8 फ़ाइल की पहचान करता है, जो जर्मन उमलाउ के साथ आईएसओ-8859-1 और यूएस-एएससीआईआई है।
ब्रेन

1
@Brain: क्या आपकी परीक्षण की गई फ़ाइल वास्तव में UTF-8 प्रारूप में है और इसमें BOM ( en.wikipedia.org/wiki/Byte_order_mark ) शामिल है?
बेनी न्युगबॉएर

@BennyNeugebauer फ़ाइल BOM के बिना UTF-8 है। मैंने इसे नोटपैड ++ के साथ चेक किया, एन्कोडिंग को बदलकर और यह भी दावा करते हुए कि "उमल्यूट" अभी भी दिखाई दे रहे हैं।
ब्रेन

13

आप निश्चित रूप से फ़ाइल को किसी विशेष चारसेट के लिए इसे डिकोड करके और "विकृत-इनपुट" या "अयोग्य-वर्ण" त्रुटियों के लिए देख कर सत्यापित कर सकते हैं। बेशक, यह केवल आपको बताता है कि क्या कोई गड़बड़ी गलत है; अगर यह सही है तो यह आपको नहीं बताता है। उसके लिए, आपको डिकोड किए गए परिणामों का मूल्यांकन करने के लिए तुलना के आधार की आवश्यकता होती है, जैसे कि क्या आप पहले से जानते हैं कि क्या चरित्र कुछ सबसेट तक सीमित हैं, या क्या पाठ कुछ सख्त प्रारूप का पालन करता है? लब्बोलुआब यह है कि चारसेट डिटेक्शन बिना किसी गारंटी के अनुमान है।CharsetDecoder


12

किस पुस्तकालय का उपयोग करें?

इस लेखन के रूप में, वे तीन पुस्तकालय हैं जो उभरते हैं:

मैं अपाचे Any23 को शामिल नहीं करता हूं क्योंकि यह हुड के तहत ICU4j 3.4 का उपयोग करता है।

कैसे बताएं कि किसने सही चारसेट का पता लगाया है (या जितना संभव हो उतना करीब)?

प्रत्येक उपर्युक्त पुस्तकालयों द्वारा पता लगाए गए वर्ण को प्रमाणित करना असंभव है। हालांकि, बदले में उनसे पूछना संभव है और लौटी प्रतिक्रिया को स्कोर कर सकते हैं।

लौटी प्रतिक्रिया को कैसे स्कोर करें?

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

क्या कोई नमूना कोड है?

यहां पिछली पंक्तियों में वर्णित रणनीति को लागू करने वाला एक पूरा स्निपेट है।

public static String guessEncoding(InputStream input) throws IOException {
    // Load input data
    long count = 0;
    int n = 0, EOF = -1;
    byte[] buffer = new byte[4096];
    ByteArrayOutputStream output = new ByteArrayOutputStream();

    while ((EOF != (n = input.read(buffer))) && (count <= Integer.MAX_VALUE)) {
        output.write(buffer, 0, n);
        count += n;
    }
    
    if (count > Integer.MAX_VALUE) {
        throw new RuntimeException("Inputstream too large.");
    }

    byte[] data = output.toByteArray();

    // Detect encoding
    Map<String, int[]> encodingsScores = new HashMap<>();

    // * GuessEncoding
    updateEncodingsScores(encodingsScores, new CharsetToolkit(data).guessEncoding().displayName());

    // * ICU4j
    CharsetDetector charsetDetector = new CharsetDetector();
    charsetDetector.setText(data);
    charsetDetector.enableInputFilter(true);
    CharsetMatch cm = charsetDetector.detect();
    if (cm != null) {
        updateEncodingsScores(encodingsScores, cm.getName());
    }

    // * juniversalchardset
    UniversalDetector universalDetector = new UniversalDetector(null);
    universalDetector.handleData(data, 0, data.length);
    universalDetector.dataEnd();
    String encodingName = universalDetector.getDetectedCharset();
    if (encodingName != null) {
        updateEncodingsScores(encodingsScores, encodingName);
    }

    // Find winning encoding
    Map.Entry<String, int[]> maxEntry = null;
    for (Map.Entry<String, int[]> e : encodingsScores.entrySet()) {
        if (maxEntry == null || (e.getValue()[0] > maxEntry.getValue()[0])) {
            maxEntry = e;
        }
    }

    String winningEncoding = maxEntry.getKey();
    //dumpEncodingsScores(encodingsScores);
    return winningEncoding;
}

private static void updateEncodingsScores(Map<String, int[]> encodingsScores, String encoding) {
    String encodingName = encoding.toLowerCase();
    int[] encodingScore = encodingsScores.get(encodingName);

    if (encodingScore == null) {
        encodingsScores.put(encodingName, new int[] { 1 });
    } else {
        encodingScore[0]++;
    }
}    

private static void dumpEncodingsScores(Map<String, int[]> encodingsScores) {
    System.out.println(toString(encodingsScores));
}

private static String toString(Map<String, int[]> encodingsScores) {
    String GLUE = ", ";
    StringBuilder sb = new StringBuilder();

    for (Map.Entry<String, int[]> e : encodingsScores.entrySet()) {
        sb.append(e.getKey() + ":" + e.getValue()[0] + GLUE);
    }
    int len = sb.length();
    sb.delete(len - GLUE.length(), len);

    return "{ " + sb.toString() + " }";
}

सुधार:guessEncoding विधि InputStream पूरी तरह पढ़ता है। बड़ी इनपुटस्ट्रीम के लिए यह एक चिंता का विषय हो सकता है। इन सभी पुस्तकालयों में पूरी इनपुटस्ट्रीम पढ़ी जाएगी। यह चारसेट का पता लगाने के लिए एक बड़े समय की खपत होगी।

प्रारंभिक डेटा लोडिंग को कुछ बाइट्स तक सीमित करना और केवल कुछ बाइट्स पर चारसेट का पता लगाना संभव है।


8

ऊपर दिए गए कार्य सरल बीओएम डिटेक्टर हैं जो फ़ाइल के आरंभ में बीओएम होने पर ही काम करते हैं। Http://jchardet.sourceforge.net/ पर एक नज़र डालें जो पाठ को स्कैन करता है


18
सिर्फ टिप पर, लेकिन इस साइट पर कोई "ऊपर" नहीं है - उन पुस्तकालयों को बताते हुए विचार करें जिनके बारे में आप बता रहे हैं।
मैकडॉवेल

6

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

मैंने HTML वेब पेजों की चारसेटिंग एन्कोडिंग का पता लगाने के लिए एक मेटा जावा उपकरण लिखा है, जो कि निर्मित घटकों के रूप में IBM ICU4j और Mozilla JCharDet का उपयोग करता है। यहां आप मेरा टूल पा सकते हैं, कृपया कुछ और से पहले README सेक्शन को पढ़ें। इसके अलावा, आप इस समस्या की कुछ बुनियादी अवधारणाओं को मेरे पेपर और इसके संदर्भों में पा सकते हैं।

Bellow मैंने कुछ उपयोगी टिप्पणियां प्रदान की हैं जिन्हें मैंने अपने काम में अनुभव किया है:

  • चारसेट का पता लगाने के लिए एक सरल प्रक्रिया है, क्योंकि यह अनिवार्य रूप से सांख्यिकीय आंकड़ों पर आधारित है और क्या वास्तव में होता है नहीं है अनुमान लगा नहीं पता लगाने
  • इस संदर्भ में आईबीएम, इहो द्वारा icu4j मुख्य उपकरण है
  • TikaEncodingDetector और Lucene-ICU4j दोनों icu4j का उपयोग कर रहे हैं और उनकी सटीकता में कोई सार्थक अंतर नहीं था, जिससे मेरे परीक्षणों में icu4j (सबसे कम 1%, जैसा कि मुझे याद है)
  • icu4j jchardet की तुलना में बहुत अधिक सामान्य है, icu4j आईबीएम परिवार के एन्कोडिंग के लिए थोड़ा सा पक्षपाती है, जबकि jchardet utf-8 के लिए दृढ़ता से पक्षपाती है
  • HTML-world में UTF-8 के व्यापक उपयोग के कारण; jchardet समग्र रूप से icu4j से बेहतर विकल्प है, लेकिन सबसे अच्छा विकल्प नहीं है!
  • icu4j पूर्व एशियाई विशिष्ट एन्कोडिंग जैसे EUC-KR, EUC-JP, SHIFT_JIS, BIG5 और GB परिवार एन्कोडिंग के लिए बहुत अच्छा है
  • Windows-1251 और Windows-1256 एन्कोडिंग के साथ HTML पृष्ठों से निपटने के लिए icu4j और jchardet दोनों पराजय है। Windows-1251 उर्फ ​​cp1251 का उपयोग व्यापक रूप से सिरिलिक-आधारित भाषाओं के लिए किया जाता है जैसे रूसी और Windows-1256 उर्फ ​​cp1256 का अरबी के लिए व्यापक रूप से उपयोग किया जाता है
  • लगभग सभी एन्कोडिंग डिटेक्शन टूल सांख्यिकीय तरीकों का उपयोग कर रहे हैं, इसलिए आउटपुट की सटीकता दृढ़ता और इनपुट की सामग्री पर निर्भर करती है
  • कुछ एनकोडिंग अनिवार्य रूप से केवल एक आंशिक अंतर के साथ ही होते हैं, इसलिए कुछ मामलों में अनुमान लगाया या पता लगाया गया एन्कोडिंग गलत हो सकता है लेकिन एक ही समय में सच हो सकता है! Windows-1252 और ISO-8859-1 के बारे में। (मेरे पेपर के 5.2 सेक्शन के तहत अंतिम पैराग्राफ देखें)

5

मुझे एक अच्छी थर्ड पार्टी लाइब्रेरी मिली जो वास्तविक एन्कोडिंग का पता लगा सकती है: http://glaforge.free.fr/wiki/index.php?wiki=GuessEncoding

मैंने बड़े पैमाने पर इसका परीक्षण नहीं किया, लेकिन यह काम करने लगता है।


"GuessEncoding" परियोजना की वेबसाइट का लिंक यह है: xircles.codehaus.org/p/guessencoding
बेन्नी

5

यदि आप ICU4J ( http://icu-project.org/apiref/icu4j/ ) का उपयोग करते हैं

यहाँ मेरा कोड है:

String charset = "ISO-8859-1"; //Default chartset, put whatever you want

byte[] fileContent = null;
FileInputStream fin = null;

//create FileInputStream object
fin = new FileInputStream(file.getPath());

/*
 * Create byte array large enough to hold the content of the file.
 * Use File.length to determine size of the file in bytes.
 */
fileContent = new byte[(int) file.length()];

/*
 * To read content of the file in byte array, use
 * int read(byte[] byteArray) method of java FileInputStream class.
 *
 */
fin.read(fileContent);

byte[] data =  fileContent;

CharsetDetector detector = new CharsetDetector();
detector.setText(data);

CharsetMatch cm = detector.detect();

if (cm != null) {
    int confidence = cm.getConfidence();
    System.out.println("Encoding: " + cm.getName() + " - Confidence: " + confidence + "%");
    //Here you have the encode name and the confidence
    //In my case if the confidence is > 50 I return the encode, else I return the default value
    if (confidence > 50) {
        charset = cm.getName();
    }
}

सभी की जरूरत है पकड़ने के लिए याद रखें।

मुझे उम्मीद है कि यह आपके लिए काम करेगा।


IMO, यह जवाब एकदम सही है। आप ICU4j उपयोग करना चाहते हैं, यह एक ऐसा करें: stackoverflow.com/a/4013565/363573
स्टीफन

4

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


2

ISO8859_1 फ़ाइलों के लिए, उन्हें ASCII से अलग करने का एक आसान तरीका नहीं है। हालांकि यूनिकोड फ़ाइलों के लिए आम तौर पर फ़ाइल के पहले कुछ बाइट्स के आधार पर इसका पता लगाया जा सकता है।

UTF-8 और UTF-16 फ़ाइलों में फ़ाइल के आरंभ में एक बाइट ऑर्डर मार्क (BOM) शामिल है। बीओएम एक शून्य-चौड़ाई वाला गैर-ब्रेकिंग स्पेस है।

दुर्भाग्य से, ऐतिहासिक कारणों से, जावा स्वचालित रूप से इसका पता नहीं लगाता है। नोटपैड जैसे कार्यक्रम बीओएम की जांच करेंगे और उपयुक्त एन्कोडिंग का उपयोग करेंगे। यूनिक्स या Cygwin का उपयोग करके, आप BOM को फ़ाइल कमांड के साथ देख सकते हैं। उदाहरण के लिए:

$ file sample2.sql 
sample2.sql: Unicode text, UTF-16, big-endian

जावा के लिए, मेरा सुझाव है कि आप इस कोड को देखें, जो सामान्य फ़ाइल स्वरूपों का पता लगाएगा और सही एन्कोडिंग का चयन करेगा: किसी फ़ाइल को कैसे पढ़ें और स्वचालित रूप से सही एन्कोडिंग निर्दिष्ट करें


15
सभी UTF-8 या UTF-16 फ़ाइलों में BOM नहीं है, क्योंकि इसकी आवश्यकता नहीं है, और UTF-8 BOM को हतोत्साहित किया जाता है।
क्रिस्टोफर हैमरस्ट्रॉम्ड

1

TikaEncodingDetector का एक विकल्प Tika AutoDetectReader का उपयोग करना है

Charset charset = new AutoDetectReader(new FileInputStream(file)).getCharset();

Tike AutoDetectReader ServiceLoader के साथ लोड किए गए EncodingDetector का उपयोग करता है। कौन सा एन्कोडिंगडेटर इंपेक्टर आप उपयोग करते हैं?
स्टीफेन

-1

सादे जावा में:

final String[] encodings = { "US-ASCII", "ISO-8859-1", "UTF-8", "UTF-16BE", "UTF-16LE", "UTF-16" };

List<String> lines;

for (String encoding : encodings) {
    try {
        lines = Files.readAllLines(path, Charset.forName(encoding));
        for (String line : lines) {
            // do something...
        }
        break;
    } catch (IOException ioe) {
        System.out.println(encoding + " failed, trying next.");
    }
}

यह दृष्टिकोण एक-एक करके एन्कोडिंग की कोशिश करेगा जब तक कि एक काम नहीं करता है या हम उनमें से बाहर निकलते हैं। (BTW मेरी एन्कोडिंग सूची में केवल वे आइटम हैं क्योंकि वे हर जावा प्लेटफ़ॉर्म पर आवश्यक चार्ट कार्यान्वयन हैं, https://docs.oracle.com/javase/9/docs/api/java/nio/charset/Carset.html )


लेकिन ISO-8859-1 (आपके द्वारा सूचीबद्ध नहीं किए गए कई अन्य लोगों के बीच) हमेशा सफल होंगे। और, ज़ाहिर है, यह सिर्फ अनुमान है, जो खोए हुए मेटाडेटा को पुनर्प्राप्त नहीं कर सकता है जो पाठ फ़ाइल संचार के लिए आवश्यक है।
टॉम ब्लोडेट

हाय @TomBlodget, क्या आप सुझाव दे रहे हैं कि एन्कोडिंग क्रम अलग होना चाहिए?
एंड्रेस

3
मैं कह रहा हूं कि कई "काम" करेंगे लेकिन केवल एक "सही" है। और आपको ISO-8859-1 के लिए परीक्षण करने की आवश्यकता नहीं है क्योंकि यह हमेशा "काम" करेगा।
टॉम ब्लोडेट

-12

क्या आप कंस्ट्रक्टर में उपयुक्त चार सेट ले सकते हैं :

new InputStreamReader(new FileInputStream(in), "ISO8859_1");

8
यहां यह देखना था कि क्या चारसेट को कार्यक्रम के अनुसार निर्धारित किया जा सकता है।
जोएल

1
नहीं, यह आपके लिए अनुमान नहीं लगाएगा। आपको इसकी आपूर्ति करनी होगी।
केविन

1
यहाँ कुछ उत्तर के अनुसार सुझाव दिया जा सकता है, एक विधिपूर्ण विधि हो सकती है, यहाँ stackoverflow.com/questions/457655/java-charset-and-windows/…
जोएल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.