दिलचस्प पोस्ट
जावा ऐप से एक विंडोज़ सेवा बनाने के लिए कैसे करें पायथन: जेसन.लोड्स 'यू' के साथ पूर्वनिर्धारित आइटम देता है जावा का उपयोग करने वाले विंडोज कमांड को कैसे निष्पादित करें – नेटवर्क सेटिंग्स बदलें क्या मैं एक ही कंप्यूटर पर पायथन 3.x और 2.x को स्थापित कर सकता हूं? मैटप्ललिब में घनत्व से रंग कैसे बना सकता हूं? डुप्लिकेट्स को सूची से <T> सी # में हटाएं PHP में एक सत्र से लॉगआउट करने का उचित तरीका फ्लक्स ऐप में एजेक्स अनुरोध को कहाँ बनाया जाना चाहिए? मैं सी # में प्रक्रिया द्वारा खुली फ़ाइल की सूची कैसे प्राप्त करूं? क्या जावा के लिए एक परिष्कृत फाइल सिस्टम मॉनिटर है जो फ्रीवेयर या ओपन सोर्स है? एक jQuery UI संवाद में डेटा पास करना फ्लोट परिवर्तन परिणाम लौटने के तरीके में फ्लोट करने के लिए एक परिणाम कास्टिंग करना सामग्री के आधार पर एक आइफ्रेम का आकार बदलना मैं एक (यूनिक्स) शैल स्क्रिप्ट में JSON को बहुत प्रिंट कैसे कर सकता / सकती हूं? JSON पर HTML को मानचित्र दें

बाइट ऑर्डर मार्क स्क्रू अप फाइल पढ़ने में जावा

मैं जावा का उपयोग कर सीएसवी फाइलों को पढ़ने की कोशिश कर रहा हूं। कुछ फ़ाइलों की शुरुआत में एक बाइट क्रम चिह्न हो सकता है, लेकिन सभी नहीं। जब वर्तमान में, बाइट ऑर्डर को दूसरी पंक्ति के साथ पढ़ा जाता है, इस प्रकार स्ट्रिंग की तुलना में समस्याएं पैदा होती हैं।

क्या यह मौजूद है जब बाइट क्रम के निशान को छोड़ने का एक आसान तरीका है?

धन्यवाद!

वेब के समाधान से एकत्रित समाधान "बाइट ऑर्डर मार्क स्क्रू अप फाइल पढ़ने में जावा"

संपादित करें : मैंने GitHub पर एक उचित रिहाई की है: https://github.com/gpakosz/UnicodeBOMInputStream


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

/* ____________________________________________________________________________ * * File: UnicodeBOMInputStream.java * Author: Gregory Pakosz. * Date: 02 - November - 2005 * ____________________________________________________________________________ */ package com.stackoverflow.answer; import java.io.IOException; import java.io.InputStream; import java.io.PushbackInputStream; /** * The <code>UnicodeBOMInputStream</code> class wraps any * <code>InputStream</code> and detects the presence of any Unicode BOM * (Byte Order Mark) at its beginning, as defined by * <a href="http://www.faqs.org/rfcs/rfc3629.html">RFC 3629 - UTF-8, a transformation format of ISO 10646</a> * * <p>The * <a href="http://www.unicode.org/unicode/faq/utf_bom.html">Unicode FAQ</a> * defines 5 types of BOMs:<ul> * <li><pre>00 00 FE FF = UTF-32, big-endian</pre></li> * <li><pre>FF FE 00 00 = UTF-32, little-endian</pre></li> * <li><pre>FE FF = UTF-16, big-endian</pre></li> * <li><pre>FF FE = UTF-16, little-endian</pre></li> * <li><pre>EF BB BF = UTF-8</pre></li> * </ul></p> * * <p>Use the {@link #getBOM()} method to know whether a BOM has been detected * or not. * </p> * <p>Use the {@link #skipBOM()} method to remove the detected BOM from the * wrapped <code>InputStream</code> object.</p> */ public class UnicodeBOMInputStream extends InputStream { /** * Type safe enumeration class that describes the different types of Unicode * BOMs. */ public static final class BOM { /** * NONE. */ public static final BOM NONE = new BOM(new byte[]{},"NONE"); /** * UTF-8 BOM (EF BB BF). */ public static final BOM UTF_8 = new BOM(new byte[]{(byte)0xEF, (byte)0xBB, (byte)0xBF}, "UTF-8"); /** * UTF-16, little-endian (FF FE). */ public static final BOM UTF_16_LE = new BOM(new byte[]{ (byte)0xFF, (byte)0xFE}, "UTF-16 little-endian"); /** * UTF-16, big-endian (FE FF). */ public static final BOM UTF_16_BE = new BOM(new byte[]{ (byte)0xFE, (byte)0xFF}, "UTF-16 big-endian"); /** * UTF-32, little-endian (FF FE 00 00). */ public static final BOM UTF_32_LE = new BOM(new byte[]{ (byte)0xFF, (byte)0xFE, (byte)0x00, (byte)0x00}, "UTF-32 little-endian"); /** * UTF-32, big-endian (00 00 FE FF). */ public static final BOM UTF_32_BE = new BOM(new byte[]{ (byte)0x00, (byte)0x00, (byte)0xFE, (byte)0xFF}, "UTF-32 big-endian"); /** * Returns a <code>String</code> representation of this <code>BOM</code> * value. */ public final String toString() { return description; } /** * Returns the bytes corresponding to this <code>BOM</code> value. */ public final byte[] getBytes() { final int length = bytes.length; final byte[] result = new byte[length]; // Make a defensive copy System.arraycopy(bytes,0,result,0,length); return result; } private BOM(final byte bom[], final String description) { assert(bom != null) : "invalid BOM: null is not allowed"; assert(description != null) : "invalid description: null is not allowed"; assert(description.length() != 0) : "invalid description: empty string is not allowed"; this.bytes = bom; this.description = description; } final byte bytes[]; private final String description; } // BOM /** * Constructs a new <code>UnicodeBOMInputStream</code> that wraps the * specified <code>InputStream</code>. * * @param inputStream an <code>InputStream</code>. * * @throws NullPointerException when <code>inputStream</code> is * <code>null</code>. * @throws IOException on reading from the specified <code>InputStream</code> * when trying to detect the Unicode BOM. */ public UnicodeBOMInputStream(final InputStream inputStream) throws NullPointerException, IOException { if (inputStream == null) throw new NullPointerException("invalid input stream: null is not allowed"); in = new PushbackInputStream(inputStream,4); final byte bom[] = new byte[4]; final int read = in.read(bom); switch(read) { case 4: if ((bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) && (bom[2] == (byte)0x00) && (bom[3] == (byte)0x00)) { this.bom = BOM.UTF_32_LE; break; } else if ((bom[0] == (byte)0x00) && (bom[1] == (byte)0x00) && (bom[2] == (byte)0xFE) && (bom[3] == (byte)0xFF)) { this.bom = BOM.UTF_32_BE; break; } case 3: if ((bom[0] == (byte)0xEF) && (bom[1] == (byte)0xBB) && (bom[2] == (byte)0xBF)) { this.bom = BOM.UTF_8; break; } case 2: if ((bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE)) { this.bom = BOM.UTF_16_LE; break; } else if ((bom[0] == (byte)0xFE) && (bom[1] == (byte)0xFF)) { this.bom = BOM.UTF_16_BE; break; } default: this.bom = BOM.NONE; break; } if (read > 0) in.unread(bom,0,read); } /** * Returns the <code>BOM</code> that was detected in the wrapped * <code>InputStream</code> object. * * @return a <code>BOM</code> value. */ public final BOM getBOM() { // BOM type is immutable. return bom; } /** * Skips the <code>BOM</code> that was found in the wrapped * <code>InputStream</code> object. * * @return this <code>UnicodeBOMInputStream</code>. * * @throws IOException when trying to skip the BOM from the wrapped * <code>InputStream</code> object. */ public final synchronized UnicodeBOMInputStream skipBOM() throws IOException { if (!skipped) { in.skip(bom.bytes.length); skipped = true; } return this; } /** * {@inheritDoc} */ public int read() throws IOException { return in.read(); } /** * {@inheritDoc} */ public int read(final byte b[]) throws IOException, NullPointerException { return in.read(b,0,b.length); } /** * {@inheritDoc} */ public int read(final byte b[], final int off, final int len) throws IOException, NullPointerException { return in.read(b,off,len); } /** * {@inheritDoc} */ public long skip(final long n) throws IOException { return in.skip(n); } /** * {@inheritDoc} */ public int available() throws IOException { return in.available(); } /** * {@inheritDoc} */ public void close() throws IOException { in.close(); } /** * {@inheritDoc} */ public synchronized void mark(final int readlimit) { in.mark(readlimit); } /** * {@inheritDoc} */ public synchronized void reset() throws IOException { in.reset(); } /** * {@inheritDoc} */ public boolean markSupported() { return in.markSupported(); } private final PushbackInputStream in; private final BOM bom; private boolean skipped = false; } // UnicodeBOMInputStream 

और आप इसे इस तरह से उपयोग कर रहे हैं:

 import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; public final class UnicodeBOMInputStreamUsage { public static void main(final String[] args) throws Exception { FileInputStream fis = new FileInputStream("test/offending_bom.txt"); UnicodeBOMInputStream ubis = new UnicodeBOMInputStream(fis); System.out.println("detected BOM: " + ubis.getBOM()); System.out.print("Reading the content of the file without skipping the BOM: "); InputStreamReader isr = new InputStreamReader(ubis); BufferedReader br = new BufferedReader(isr); System.out.println(br.readLine()); br.close(); isr.close(); ubis.close(); fis.close(); fis = new FileInputStream("test/offending_bom.txt"); ubis = new UnicodeBOMInputStream(fis); isr = new InputStreamReader(ubis); br = new BufferedReader(isr); ubis.skipBOM(); System.out.print("Reading the content of the file after skipping the BOM: "); System.out.println(br.readLine()); br.close(); isr.close(); ubis.close(); fis.close(); } } // UnicodeBOMInputStreamUsage 

अपाचे कॉमन्स आईओ लाइब्रेरी में एक BOMInputStream BOM को पता लगा सकता है और त्याग सकता है: BOMInputStream (javadoc) :

 BOMInputStream bomIn = new BOMInputStream(in); int firstNonBOMByte = bomIn.read(); // Skips BOM if (bomIn.hasBOM()) { // has a UTF-8 BOM } 

यदि आपको अलग-अलग एन्कोडिंग्स का पता लगाना भी पड़ता है, तो यह विभिन्न विभिन्न बाइट-ऑर्डर के अंकों के बीच अंतर भी कर सकता है, उदाहरण के लिए यूटीएफ -8 बनाम यूटीएफ -16 बड़ा + छोटा एंडियन – इसके बाद के संस्करण दस्तावेज़ लिंक पर विवरण। आप स्ट्रीम को डीकोड करने के लिए एक ByteOrderMark चुनने के लिए तब पता लगाए गए ByteOrderMark का उपयोग कर सकते हैं। (शायद यह करने के लिए एक अधिक सुव्यवस्थित तरीका है यदि आपको इस सभी कार्यक्षमता की आवश्यकता है – शायद बाल्सस के उत्तर में यूनिकोड रीडर?)। ध्यान दें, सामान्य तौर पर, यह पता लगाने का कोई बहुत अच्छा तरीका नहीं है कि कुछ बाइट्स एन्कोडिंग में हैं, लेकिन यदि स्ट्रीम एक BOM के साथ शुरू होती है, तो जाहिरा तौर पर यह सहायक हो सकता है

संपादित करें : यदि आपको UTF-16, UTF-32, आदि में BOM का पता लगाना है, तो निर्माता होना चाहिए:

 new BOMInputStream(is, ByteOrderMark.UTF_8, ByteOrderMark.UTF_16BE, ByteOrderMark.UTF_16LE, ByteOrderMark.UTF_32BE, ByteOrderMark.UTF_32LE) 

@ मार्टिन-चार्ल्सवर्थ की टिप्पणी का जवाब दें

अधिक सरल समाधान:

 public class BOMSkipper { public static void skip(Reader reader) throws IOException { reader.mark(1); char[] possibleBOM = new char[1]; reader.read(possibleBOM); if (possibleBOM[0] != '\ufeff') { reader.reset(); } } } 

उपयोग का नमूना:

 BufferedReader input = new BufferedReader(new InputStreamReader(new FileInputStream(file), fileExpectedCharset)); BOMSkipper.skip(input); //Now UTF prefix not present: input.readLine(); ... 

यह सभी 5 यूटीएफ एनकोडिंग के साथ काम करता है!

Google डेटा एपीआई में एक UnicodeReader जो UnicodeReader से एन्कोडिंग का पता लगाता है।

आप इसे InputStreamReader बजाय इसका उपयोग कर सकते हैं। यहां एक सघन रूप से कॉम्पैक्ट किया गया- इसके स्रोत का निकालने जो काफी आसान है:

 public class UnicodeReader extends Reader { private static final int BOM_SIZE = 4; private final InputStreamReader reader; /** * Construct UnicodeReader * @param in Input stream. * @param defaultEncoding Default encoding to be used if BOM is not found, * or <code>null</code> to use system default encoding. * @throws IOException If an I/O error occurs. */ public UnicodeReader(InputStream in, String defaultEncoding) throws IOException { byte bom[] = new byte[BOM_SIZE]; String encoding; int unread; PushbackInputStream pushbackStream = new PushbackInputStream(in, BOM_SIZE); int n = pushbackStream.read(bom, 0, bom.length); // Read ahead four bytes and check for BOM marks. if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) { encoding = "UTF-8"; unread = n - 3; } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) { encoding = "UTF-16BE"; unread = n - 2; } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) { encoding = "UTF-16LE"; unread = n - 2; } else if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00) && (bom[2] == (byte) 0xFE) && (bom[3] == (byte) 0xFF)) { encoding = "UTF-32BE"; unread = n - 4; } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00) && (bom[3] == (byte) 0x00)) { encoding = "UTF-32LE"; unread = n - 4; } else { encoding = defaultEncoding; unread = n; } // Unread bytes if necessary and skip BOM marks. if (unread > 0) { pushbackStream.unread(bom, (n - unread), unread); } else if (unread < -1) { pushbackStream.unread(bom, 0, 0); } // Use given encoding. if (encoding == null) { reader = new InputStreamReader(pushbackStream); } else { reader = new InputStreamReader(pushbackStream, encoding); } } public String getEncoding() { return reader.getEncoding(); } public int read(char[] cbuf, int off, int len) throws IOException { return reader.read(cbuf, off, len); } public void close() throws IOException { reader.close(); } } 

Apache Commons IO लाइब्रेरी के BOMInputStream @rescdsk द्वारा पहले ही उल्लेख किया जा चुका है, लेकिन मैंने यह नहीं बताया कि कैसे BOM के बिना एक InputStream प्राप्त करने के लिए।

यहां बताया गया है कि स्काला में मैंने यह कैसे किया

  import java.io._ val file = new File(path_to_xml_file_with_BOM) val fileInpStream = new FileInputStream(file) val bomIn = new BOMInputStream(fileInpStream, false); // false means don't include BOM 

अफसोस नहीं। आपको अपने आप को पहचानना होगा और छोड़ देना होगा यह पृष्ठ बताता है कि आपको क्या देखना है। अधिक विवरणों के लिए यह इतना प्रश्न देखें।

बस अपनी फ़ाइल से BOM वर्णों को निकालने के लिए, मैं अपाचे सामान्य आईओ का उपयोग करने की सिफारिश करता हूं

 public BOMInputStream(InputStream delegate, boolean include) Constructs a new BOM InputStream that detects aa ByteOrderMark.UTF_8 and optionally includes it. Parameters: delegate - the InputStream to delegate to include - true to include the UTF-8 BOM or false to exclude it 

सेट झूठी में शामिल है और आपके BOM वर्णों को बाहर रखा जाएगा।