inputstream.html

API資料大全

 at most, equal to the length of <code>b</code>. Let <i>k</i> be the
 number of bytes actually read; these bytes will be stored in elements
 <code>b[0]</code> through <code>b[</code><i>k</i><code>-1]</code>,
 leaving elements <code>b[</code><i>k</i><code>]</code> through
 <code>b[b.length-1]</code> unaffected.

 <p> If the first byte cannot be read for any reason other than end of
 file, then an <code>IOException</code> is thrown. In particular, an
 <code>IOException</code> is thrown if the input stream has been closed.

 <p> The <code>read(b)</code> method for class <code>InputStream</code>
 has the same effect as: <pre><code> read(b, 0, b.length) </code></pre><DD><DL>
<DT><B>Parameters:</B><DD><CODE>b</CODE> - the buffer into which the data is read.<DT><B>Returns:</B><DD>the total number of bytes read into the buffer, or
             <code>-1</code> is there is no more data because the end of
             the stream has been reached.<DT><B>Throws:</B><DD><CODE><A HREF="../../java/io/IOException.html">IOException</A></CODE> - if an I/O error occurs.<DT><B>See Also: </B><DD><A HREF="../../java/io/InputStream.html#read(byte[], int, int)"><CODE>read(byte[], int, int)</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="read(byte[], int, int)"><!-- --></A><H3>
read</H3>
<PRE>
public int <B>read</B>(byte[]&nbsp;b,
                int&nbsp;off,
                int&nbsp;len)
         throws <A HREF="../../java/io/IOException.html">IOException</A></PRE>
<DL>
<DD>Reads up to <code>len</code> bytes of data from the input stream into
 an array of bytes.  An attempt is made to read as many as
 <code>len</code> bytes, but a smaller number may be read, possibly
 zero. The number of bytes actually read is returned as an integer.

 <p> This method blocks until input data is available, end of file is
 detected, or an exception is thrown.

 <p> If <code>b</code> is <code>null</code>, a
 <code>NullPointerException</code> is thrown.

 <p> If <code>off</code> is negative, or <code>len</code> is negative, or
 <code>off+len</code> is greater than the length of the array
 <code>b</code>, then an <code>IndexOutOfBoundsException</code> is
 thrown.

 <p> If <code>len</code> is zero, then no bytes are read and
 <code>0</code> is returned; otherwise, there is an attempt to read at
 least one byte. If no byte is available because the stream is at end of
 file, the value <code>-1</code> is returned; otherwise, at least one
 byte is read and stored into <code>b</code>.

 <p> The first byte read is stored into element <code>b[off]</code>, the
 next one into <code>b[off+1]</code>, and so on. The number of bytes read
 is, at most, equal to <code>len</code>. Let <i>k</i> be the number of
 bytes actually read; these bytes will be stored in elements
 <code>b[off]</code> through <code>b[off+</code><i>k</i><code>-1]</code>,
 leaving elements <code>b[off+</code><i>k</i><code>]</code> through
 <code>b[off+len-1]</code> unaffected.

 <p> In every case, elements <code>b[0]</code> through
 <code>b[off]</code> and elements <code>b[off+len]</code> through
 <code>b[b.length-1]</code> are unaffected.

 <p> If the first byte cannot be read for any reason other than end of
 file, then an <code>IOException</code> is thrown. In particular, an
 <code>IOException</code> is thrown if the input stream has been closed.

 <p> The <code>read(b,</code> <code>off,</code> <code>len)</code> method
 for class <code>InputStream</code> simply calls the method
 <code>read()</code> repeatedly. If the first such call results in an
 <code>IOException</code>, that exception is returned from the call to
 the <code>read(b,</code> <code>off,</code> <code>len)</code> method.  If
 any subsequent call to <code>read()</code> results in a
 <code>IOException</code>, the exception is caught and treated as if it
 were end of file; the bytes read up to that point are stored into
 <code>b</code> and the number of bytes read before the exception
 occurred is returned.  Subclasses are encouraged to provide a more
 efficient implementation of this method.<DD><DL>
<DT><B>Parameters:</B><DD><CODE>b</CODE> - the buffer into which the data is read.<DD><CODE>off</CODE> - the start offset in array <code>b</code>
                   at which the data is written.<DD><CODE>len</CODE> - the maximum number of bytes to read.<DT><B>Returns:</B><DD>the total number of bytes read into the buffer, or
             <code>-1</code> if there is no more data because the end of
             the stream has been reached.<DT><B>Throws:</B><DD><CODE><A HREF="../../java/io/IOException.html">IOException</A></CODE> - if an I/O error occurs.<DT><B>See Also: </B><DD><A HREF="../../java/io/InputStream.html#read()"><CODE>read()</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="skip(long)"><!-- --></A><H3>
skip</H3>
<PRE>
public long <B>skip</B>(long&nbsp;n)
          throws <A HREF="../../java/io/IOException.html">IOException</A></PRE>
<DL>
<DD>Skips over and discards <code>n</code> bytes of data from this input
 stream. The <code>skip</code> method may, for a variety of reasons, end
 up skipping over some smaller number of bytes, possibly <code>0</code>.
 This may result from any of a number of conditions; reaching end of file
 before <code>n</code> bytes have been skipped is only one possibility.
 The actual number of bytes skipped is returned.  If <code>n</code> is
 negative, no bytes are skipped.

 <p> The <code>skip</code> method of <code>InputStream</code> creates a
 byte array and then repeatedly reads into it until <code>n</code> bytes
 have been read or the end of the stream has been reached. Subclasses are
 encouraged to provide a more efficient implementation of this method.<DD><DL>
<DT><B>Parameters:</B><DD><CODE>n</CODE> - the number of bytes to be skipped.<DT><B>Returns:</B><DD>the actual number of bytes skipped.<DT><B>Throws:</B><DD><CODE><A HREF="../../java/io/IOException.html">IOException</A></CODE> - if an I/O error occurs.</DL>
</DD>
</DL>
<HR>

<A NAME="available()"><!-- --></A><H3>
available</H3>
<PRE>
public int <B>available</B>()
              throws <A HREF="../../java/io/IOException.html">IOException</A></PRE>
<DL>
<DD>Returns the number of bytes that can be read (or skipped over) from
 this input stream without blocking by the next caller of a method for
 this input stream.  The next caller might be the same thread or or
 another thread.

 <p> The <code>available</code> method for class <code>InputStream</code>
 always returns <code>0</code>.

 <p> This method should be overridden by subclasses.<DD><DL>
<DT><B>Returns:</B><DD>the number of bytes that can be read from this input stream
             without blocking.<DT><B>Throws:</B><DD><CODE><A HREF="../../java/io/IOException.html">IOException</A></CODE> - if an I/O error occurs.</DL>
</DD>
</DL>
<HR>

<A NAME="close()"><!-- --></A><H3>
close</H3>
<PRE>
public void <B>close</B>()
           throws <A HREF="../../java/io/IOException.html">IOException</A></PRE>
<DL>
<DD>Closes this input stream and releases any system resources associated
 with the stream.

 <p> The <code>close</code> method of <code>InputStream</code> does
 nothing.<DD><DL>
<DT><B>Throws:</B><DD><CODE><A HREF="../../java/io/IOException.html">IOException</A></CODE> - if an I/O error occurs.</DL>
</DD>
</DL>
<HR>

<A NAME="mark(int)"><!-- --></A><H3>
mark</H3>
<PRE>
public void <B>mark</B>(int&nbsp;readlimit)</PRE>
<DL>
<DD>Marks the current position in this input stream. A subsequent call to
 the <code>reset</code> method repositions this stream at the last marked
 position so that subsequent reads re-read the same bytes.

 <p> The <code>readlimit</code> arguments tells this input stream to
 allow that many bytes to be read before the mark position gets
 invalidated.

 <p> The general contract of <code>mark</code> is that, if the method
 <code>markSupported</code> returns <code>true</code>, the stream somehow
 remembers all the bytes read after the call to <code>mark</code> and
 stands ready to supply those same bytes again if and whenever the method
 <code>reset</code> is called.  However, the stream is not required to
 remember any data at all if more than <code>readlimit</code> bytes are
 read from the stream before <code>reset</code> is called.

 <p> The <code>mark</code> method of <code>InputStream</code> does
 nothing.<DD><DL>
<DT><B>Parameters:</B><DD><CODE>readlimit</CODE> - the maximum limit of bytes that can be read before
                      the mark position becomes invalid.<DT><B>See Also: </B><DD><A HREF="../../java/io/InputStream.html#reset()"><CODE>reset()</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="reset()"><!-- --></A><H3>
reset</H3>
<PRE>
public void <B>reset</B>()
           throws <A HREF="../../java/io/IOException.html">IOException</A></PRE>
<DL>
<DD>Repositions this stream to the position at the time the
 <code>mark</code> method was last called on this input stream.

 <p> The general contract of <code>reset</code> is:

 <p><ul>

 <li> If the method <code>markSupported</code> returns
 <code>true</code>, then:

     <ul><li> If the method <code>mark</code> has not been called since
     the stream was created, or the number of bytes read from the stream
     since <code>mark</code> was last called is larger than the argument
     to <code>mark</code> at that last call, then an
     <code>IOException</code> might be thrown.

     <li> If such an <code>IOException</code> is not thrown, then the
     stream is reset to a state such that all the bytes read since the
     most recent call to <code>mark</code> (or since the start of the
     file, if <code>mark</code> has not been called) will be resupplied
     to subsequent callers of the <code>read</code> method, followed by
     any bytes that otherwise would have been the next input data as of
     the time of the call to <code>reset</code>. </ul>

 <li> If the method <code>markSupported</code> returns
 <code>false</code>, then:

     <ul><li> The call to <code>reset</code> may throw an
     <code>IOException</code>.

     <li> If an <code>IOException</code> is not thrown, then the stream
     is reset to a fixed state that depends on the particular type of the
     input stream and how it was created. The bytes that will be supplied
     to subsequent callers of the <code>read</code> method depend on the
     particular type of the input stream. </ul></ul>

 <p> The method <code>reset</code> for class <code>InputStream</code>
 does nothing and always throws an <code>IOException</code>.<DD><DL>
<DT><B>Throws:</B><DD><CODE><A HREF="../../java/io/IOException.html">IOException</A></CODE> - if this stream has not been marked or if the
               mark has been invalidated.<DT><B>See Also: </B><DD><A HREF="../../java/io/InputStream.html#mark(int)"><CODE>mark(int)</CODE></A>, 
<A HREF="../../java/io/IOException.html"><CODE>IOException</CODE></A></DL>
</DD>
</DL>
<HR>

<A NAME="markSupported()"><!-- --></A><H3>
markSupported</H3>
<PRE>
public boolean <B>markSupported</B>()</PRE>
<DL>
<DD>Tests if this input stream supports the <code>mark</code> and
 <code>reset</code> methods. The <code>markSupported</code> method of
 <code>InputStream</code> returns <code>false</code>.<DD><DL>
<DT><B>Returns:</B><DD><code>true</code> if this true type supports the mark and reset
          method; <code>false</code> otherwise.<DT><B>See Also: </B><DD><A HREF="../../java/io/InputStream.html#mark(int)"><CODE>mark(int)</CODE></A>, 
<A HREF="../../java/io/InputStream.html#reset()"><CODE>reset()</CODE></A></DL>
</DD>
</DL>
<!-- ========= END OF CLASS DATA ========= -->
<HR>

<!-- ========== START OF NAVBAR ========== -->
<A NAME="navbar_bottom"><!-- --></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_bottom_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="../../overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Class</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="class-use/InputStream.html"><FONT CLASS="NavBarFont1"><B>Use</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="../../deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="../../index-files/index-1.html"><FONT CLASS="NavBarFont1"><B>Index</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="../../help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
<b>Java<sup><font size=-2>TM</font></sup>&nbsp;2&nbsp;Platform<br>Std.&nbsp;Ed. v1.3</b></EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;<A HREF="../../java/io/FilterWriter.html"><B>PREV CLASS</B></A>&nbsp;
&nbsp;<A HREF="../../java/io/InputStreamReader.html"><B>NEXT CLASS</B></A></FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="../../index.html" TARGET="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="InputStream.html" TARGET="_top"><B>NO FRAMES</B></A></FONT></TD>
</TR>
<TR>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
  SUMMARY: &nbsp;INNER&nbsp;|&nbsp;FIELD&nbsp;|&nbsp;<A HREF="#constructor_summary">CONSTR</A>&nbsp;|&nbsp;<A HREF="#method_summary">METHOD</A></FONT></TD>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
DETAIL: &nbsp;FIELD&nbsp;|&nbsp;<A HREF="#constructor_detail">CONSTR</A>&nbsp;|&nbsp;<A HREF="#method_detail">METHOD</A></FONT></TD>
</TR>
</TABLE>
<!-- =========== END OF NAVBAR =========== -->

<HR>
<font size="-1"><a href="http://java.sun.com/cgi-bin/bugreport.cgi">Submit a bug or feature</a><br>For further API reference and developer documentation, see <a href="http://java.sun.com/products/jdk/1.3/devdocs-vs-specs.html">Java 2 SDK SE Developer Documentation</a>. That documentation  contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples. <p>Java, Java 2D, and JDBC are trademarks or registered trademarks of Sun Microsystems, Inc. in the US and other countries.<br>Copyright 1993-2000 Sun Microsystems, Inc. 901 San Antonio Road<br>Palo Alto, California, 94303, U.S.A.  All Rights Reserved.</font>
</BODY>
</HTML>