java - InputStream में मैं पहले दो बाइटों पर कैसे झलकता हूं?




bufferedinputstream (3)

BufferedInputStream का उपयोग करते समय यह सुनिश्चित करें कि इनपुटस्ट्रीम पहले से ही बफ़र नहीं है, डबल बफरिंग में कुछ गंभीरता से मुश्किल से बग ढूंढने होंगे। इसके अलावा आपको पाठकों को अलग तरीके से संभाल करने की ज़रूरत है, एक स्ट्रीम रीडर और बफरिंग में परिवर्तित करने से बाइट्स खो जाएंगे यदि रीडर बीफ़र्ड है। इसके अलावा अगर आप एक रीडर का उपयोग कर रहे हैं तो याद रखें कि आप बाइट नहीं पढ़ रहे हैं, लेकिन डिफ़ॉल्ट एन्कोडिंग में अक्षर (जब तक कि एक स्पष्ट एन्कोडिंग सेट नहीं किया गया था)। एक बफ़र इनपुट स्ट्रीम का एक उदाहरण, जिसे आप नहीं जान सकते हैं URL यूआरएल; url.openStream ();

मेरे पास इस जानकारी के लिए कोई संदर्भ नहीं है, यह डीबगिंग कोड से आता है। मुख्य मामले जहां मेरे लिए समस्या आई है, वह कोड था जो किसी फ़ाइल से एक संपीड़ित स्ट्रीम में पढ़ता था। अगर मैं सही तरीके से याद रखता हूं, जब आप कोड के माध्यम से डीबग करना शुरू करते हैं, तो जावा स्रोत में टिप्पणियां होती हैं कि कुछ चीजें हमेशा सही ढंग से काम नहीं करतीं मुझे याद नहीं है कि बुफीडडरडर और बुफ्फ़र्ड इनटस्टस्ट्रीम का उपयोग करने से जानकारी कहां से आती है, लेकिन मुझे लगता है कि यहां तक ​​कि सरल परीक्षण पर भी असफल रहता है। यह परीक्षण करने के लिए याद रखें कि आपको बफ़र आकार (जो कि बफरेडडरर बनाम बफ़ेन्डइनपुटस्ट्रीम के लिए अलग है) से अधिक अंकन करने की आवश्यकता है, समस्या तब होती है जब बाइट्स पढ़ी जा रही है बफर के अंत तक। नोट एक स्रोत कोड बफर आकार है जो कन्स्ट्रक्टर में सेट बफ़र आकार से भिन्न हो सकता है। यह थोड़ी देर है क्योंकि मैंने ऐसा किया था, इसलिए विवरणों की मेरी यादें थोड़ी दूर हो सकती हैं। एक फिल्टररिडर / फ़िल्टर इनटस्ट्रीम का उपयोग करके परीक्षण किया गया था, अंतर को देखने के लिए सीधे एक और एक बफ़र्ड स्ट्रीम में जोड़ें।

बहुत सरल होना चाहिए: मेरे पास एक इनपुट स्प्रैड है, जहां मैं पहले दो बाइट्स (पढ़ नहीं) पर झांकना चाहता हूं, यानी मुझे अपने वर्तमान देखने के बाद 0 पर रहने के लिए इनटस्टस्ट्रीम की "वर्तमान स्थिति" चाहिए। ऐसा करने का सबसे अच्छा और सबसे सुरक्षित तरीका क्या है?

उत्तर - जैसा कि मुझे संदेह था, समाधान एक बुफ़र इनटस्टस्ट्रीम में इसे लपेटने के लिए था जो मार्कअप प्रदान करता है। धन्यवाद Rasmus


मुझे यहां एक पीकेबल इन्पुट स्ट्रीम का कार्यान्वयन मिला:

http://www.heatonresearch.com/articles/147/page2.html

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

चूंकि नमूना कोड का लाइसेंस एलजीपीएल है, यह इस पोस्ट से जोड़ा जा सकता है:

package com.heatonresearch.httprecipes.html;

import java.io.*;

/**
 * The Heaton Research Spider Copyright 2007 by Heaton
 * Research, Inc.
 * 
 * HTTP Programming Recipes for Java ISBN: 0-9773206-6-9
 * http://www.heatonresearch.com/articles/series/16/
 * 
 * PeekableInputStream: This is a special input stream that
 * allows the program to peek one or more characters ahead
 * in the file.
 * 
 * This class is released under the:
 * GNU Lesser General Public License (LGPL)
 * http://www.gnu.org/copyleft/lesser.html
 * 
 * @author Jeff Heaton
 * @version 1.1
 */
public class PeekableInputStream extends InputStream
{

  /**
   * The underlying stream.
   */
  private InputStream stream;

  /**
   * Bytes that have been peeked at.
   */
  private byte peekBytes[];

  /**
   * How many bytes have been peeked at.
   */
  private int peekLength;

  /**
   * The constructor accepts an InputStream to setup the
   * object.
   * 
   * @param is
   *          The InputStream to parse.
   */
  public PeekableInputStream(InputStream is)
  {
    this.stream = is;
    this.peekBytes = new byte[10];
    this.peekLength = 0;
  }

  /**
   * Peek at the next character from the stream.
   * 
   * @return The next character.
   * @throws IOException
   *           If an I/O exception occurs.
   */
  public int peek() throws IOException
  {
    return peek(0);
  }

  /**
   * Peek at a specified depth.
   * 
   * @param depth
   *          The depth to check.
   * @return The character peeked at.
   * @throws IOException
   *           If an I/O exception occurs.
   */
  public int peek(int depth) throws IOException
  {
    // does the size of the peek buffer need to be extended?
    if (this.peekBytes.length <= depth)
    {
      byte temp[] = new byte[depth + 10];
      for (int i = 0; i < this.peekBytes.length; i++)
      {
        temp[i] = this.peekBytes[i];
      }
      this.peekBytes = temp;
    }

    // does more data need to be read?
    if (depth >= this.peekLength)
    {
      int offset = this.peekLength;
      int length = (depth - this.peekLength) + 1;
      int lengthRead = this.stream.read(this.peekBytes, offset, length);

      if (lengthRead == -1)
      {
        return -1;
      }

      this.peekLength = depth + 1;
    }

    return this.peekBytes[depth];
  }

  /*
   * Read a single byte from the stream. @throws IOException
   * If an I/O exception occurs. @return The character that
   * was read from the stream.
   */
  @Override
  public int read() throws IOException
  {
    if (this.peekLength == 0)
    {
      return this.stream.read();
    }

    int result = this.peekBytes[0];
    this.peekLength--;
    for (int i = 0; i < this.peekLength; i++)
    {
      this.peekBytes[i] = this.peekBytes[i + 1];
    }

    return result;
  }

}







bufferedinputstream