इनपुटस्ट्रीम रीडर बफरिंग समस्या

Question

मैं दुर्भाग्यवश, दो प्रकार के वर्ण एन्कोडिंग वाली फ़ाइल से डेटा पढ़ रहा हूं।

एक शीर्षलेख और शरीर है। हेडर हमेशा ASCII में होता है और उस चरित्र सेट को परिभाषित करता है जिसमें शरीर को एन्कोड किया जाता है।

हेडर निश्चित लंबाई नहीं है और इसकी सामग्री/लंबाई निर्धारित करने के लिए एक पार्सर के माध्यम से चलाया जाना चाहिए।

फ़ाइल भी काफी बड़ी हो सकती है इसलिए मुझे पूरी सामग्री को स्मृति में लाने से बचने की आवश्यकता है।

तो मैंने एक इनपुट इनपुट के साथ शुरू किया। मैं शुरुआत में एएससीआईआईआई के साथ एक इनपुटस्ट्रीम रीडर के साथ लपेटता हूं और हेडर को डीकोड करता हूं और शरीर के लिए चरित्र सेट निकालता हूं। सब अच्छा।

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

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

क्या किसी को इस मुद्दे के आसपास काम करने के लिए कोई सुझाव है? एक CharsetDecoder मैन्युअल रूप से और एक बाइट में एक बार में भोजन करना एक अच्छा विचार (संभवतः एक कस्टम रीडर कार्यान्वयन में लपेटा गया है?)

अग्रिम धन्यवाद।

संपादित करें: मेरा अंतिम समाधान एक इनपुटस्ट्रीम रीडर लिखना था जिसमें यह सुनिश्चित करने के लिए कोई बफरिंग नहीं है कि मैं शरीर के चबाने के बिना हेडर को पार्स कर सकता हूं। यद्यपि यह बहुत कुशल नहीं है, लेकिन मैं कच्चे इनपुटस्ट्रीम को BufferedInputStream के साथ लपेटता हूं, इसलिए यह कोई समस्या नहीं होगी।

// An InputStreamReader that only consumes as many bytes as is necessary 
// It does not do any read-ahead. 
public class InputStreamReaderUnbuffered extends Reader 
{ 
    private final CharsetDecoder charsetDecoder; 
    private final InputStream inputStream; 
    private final ByteBuffer byteBuffer = ByteBuffer.allocate(1); 

    public InputStreamReaderUnbuffered(InputStream inputStream, Charset charset) 
    { 
     this.inputStream = inputStream; 
     charsetDecoder = charset.newDecoder(); 
    } 

    @Override 
    public int read() throws IOException 
    { 
     boolean middleOfReading = false; 

     while (true) 
     { 
      int b = inputStream.read(); 

      if (b == -1) 
      { 
       if (middleOfReading) 
        throw new IOException("Unexpected end of stream, byte truncated"); 

       return -1; 
      } 

      byteBuffer.clear(); 
      byteBuffer.put((byte)b); 
      byteBuffer.flip(); 

      CharBuffer charBuffer = charsetDecoder.decode(byteBuffer); 

      // although this is theoretically possible this would violate the unbuffered nature 
      // of this class so we throw an exception 
      if (charBuffer.length() > 1) 
       throw new IOException("Decoded multiple characters from one byte!"); 

      if (charBuffer.length() == 1) 
       return charBuffer.get(); 

      middleOfReading = true; 
     } 
    } 

    public int read(char[] cbuf, int off, int len) throws IOException 
    { 
     for (int i = 0; i < len; i++) 
     { 
      int ch = read(); 

      if (ch == -1) 
       return i == 0 ? -1 : i; 

      cbuf[ i ] = (char)ch; 
     } 

     return len; 
    } 

    public void close() throws IOException 
    { 
     inputStream.close(); 
    } 
} 

Answer 1

आप 2 InputStream एस का उपयोग क्यों नहीं करते? एक हेडर पढ़ने के लिए और शरीर के लिए एक और।

दूसरा InputStreamskip हेडर बाइट्स होना चाहिए।

Answer 2

मेरा पहला विचार स्ट्रीम को बंद करना और InputStream#skip का उपयोग करके InputStreamReader पर स्ट्रीम देने से पहले शीर्षलेख को छोड़ने के लिए इसे फिर से खोलना है।

आप सच में, सच नहीं फ़ाइल को फिर से खोलने के लिए चाहते हैं, तो आप file descriptors का उपयोग फाइल करने के लिए एक से अधिक धारा प्राप्त करने के लिए कर सकता है, हालांकि आप आप कर सकते हैं के बाद से channels उपयोग करने के लिए फ़ाइल में एक से अधिक पदों के लिए (हो सकता है मान लें कि आप reset के साथ स्थिति को रीसेट कर सकते हैं, यह समर्थित नहीं हो सकता है)।

Answer 3

मैं सुझाव देता हूं कि शुरुआत से स्ट्रीम को नए InputStreamReader के साथ शुरू करें। शायद मान लें कि InputStream.mark समर्थित है।

Answer 4

यहां छद्म कोड है।

1. उपयोग InputStream, लेकिन यह चारों ओर एक Reader लपेट नहीं है।
2. हेडर युक्त 0 बाइट पढ़ें और उन्हें ByteArrayOutputStream में संग्रहीत करें।
3. ByteArrayOutputStream से ByteArrayInputStream बनाएँ और हैडर को डिकोड, इस बार ASCII चारसेट साथ Reader में ByteArrayInputStream लपेट दें।
4. गैर-एएससीआई इनपुट की लंबाई की गणना करें, और बाइट्स की संख्या ByteArrayOutputStream में पढ़ें।
5. दूसरा ByteArrayOutputStream से दूसरे ByteArrayInputStream बनाएँ और यह लपेट Reader साथ हैडर से चारसेट साथ।

Answer 5

यह और भी आसान है:

जैसा कि आपने कहा, आपके शीर्षक ASCII में हमेशा होता है। तो InputStream से सीधे शीर्ष लेख पढ़ा है, और जब आप इसे पूरा कर चुके हैं, सही एन्कोडिंग के साथ रीडर बनाने और पढ़ने से यह

private Reader reader; 
private InputStream stream; 

public void read() { 
    int c = 0; 
    while ((c = stream.read()) != -1) { 
     // Read encoding 
     if (headerFullyRead) { 
      reader = new InputStreamReader(stream, encoding); 
      break; 
     } 
    } 
    while ((c = reader.read()) != -1) { 
     // Handle rest of file 
    } 
} 

Answer 6

आप InputStream लपेट और सीमित कर बिल्कुल पढ़ता सिर्फ 1 बाइट के लिए तो एक समय, ऐसा लगता है कि इनपुटस्ट्रीम रीडर के अंदर बफरिंग अक्षम है।

इस तरह हमें इनपुटस्ट्रीम रीडर तर्क को फिर से लिखना नहीं है।

public class OneByteReadInputStream extends InputStream 
{ 
    private final InputStream inputStream; 

    public OneByteReadInputStream(InputStream inputStream) 
    { 
     this.inputStream = inputStream; 
    } 

    @Override 
    public int read() throws IOException 
    { 
     return inputStream.read(); 
    } 

    @Override 
    public int read(byte[] b, int off, int len) throws IOException 
    { 
     return super.read(b, off, 1); 
    } 
} 

का निर्माण करने के लिए:

new InputStreamReader(new OneByteReadInputStream(inputStream));