Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 1.1 Source Code Directory
JDK 1.1 source code directory contains Java source code for JDK 1.1 core classes:
"C:\fyicenter\jdk-1.1.8\src".
Here is the list of Java classes of the JDK 1.1 source code:
✍: FYIcenter
⏎ java/io/PushbackInputStream.java
/* * @(#)PushbackInputStream.java 1.18 01/12/10 * * Copyright 2002 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.io; /** * This class is an input stream filter that provides a buffer into which data * can be "unread." An application may unread data at any time by pushing it * back into the buffer, as long as the buffer has sufficient room. Subsequent * reads will read all of the pushed-back data in the buffer before reading * from the underlying input stream. * * <p> * This functionality is useful when a fragment of code should read * an indefinite number of data bytes that are delimited by * particular byte values. After reading the terminating byte the * code fragment can push it back, so that the next read * operation on the input stream will re-read that byte. * * @author David Connelly * @author Jonathan Payne * @version 1.18, 12/10/01 * @since JDK1.0 */ public class PushbackInputStream extends FilterInputStream { /** * The pushback buffer. * @since JDK1.1 */ protected byte[] buf; /** * The position within the pushback buffer from which the next byte will * be read. When the buffer is empty, <code>pos</code> is equal to * <code>buf.length</code>; when the buffer is full, <code>pos</code> is * equal to zero. * * @since JDK1.1 */ protected int pos; /** * Creates a new pushback input stream with a pushback buffer * of the specified size. * * @param in the input stream from which bytes will be read. * @param size the size of the pushback buffer. * @since JDK1.1 */ public PushbackInputStream(InputStream in, int size) { super(in); this.buf = new byte[size]; this.pos = size; } /** * Creates a new pushback input stream with a one-byte pushback buffer. * * @param in the input stream from which bytes will be read. */ public PushbackInputStream(InputStream in) { this(in, 1); } /** * Reads the next byte of data from this input stream. The value * byte is returned as an <code>int</code> in the range * <code>0</code> to <code>255</code>. If no byte is available * because the end of the stream has been reached, the value * <code>-1</code> is returned. This method blocks until input data * is available, the end of the stream is detected, or an exception * is thrown. * * <p> This method returns the most recently pushed-back byte, if there is * one, and otherwise calls the <code>read</code> method of its underlying * input stream and returns whatever value that method returns. * * @return the next byte of data, or <code>-1</code> if the end of the * stream has been reached. * @exception IOException if an I/O error occurs. * @see java.io.InputStream#read() */ public int read() throws IOException { if (pos < buf.length) { return buf[pos++] & 0xff; } return super.read(); } /** * Reads up to <code>len</code> bytes of data from this input stream into * an array of bytes. This method first reads any pushed-back bytes; after * that, if fewer than than <code>len</code> bytes have been read then it * reads from the underlying input stream. This method blocks until at * least 1 byte of input is available. * * @param b the buffer into which the data is read. * @param off the start offset of the data. * @param len the maximum number of bytes read. * @return 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. * @exception IOException if an I/O error occurs. */ public int read(byte[] b, int off, int len) throws IOException { if (len <= 0) { return 0; } int avail = buf.length - pos; if (avail > 0) { if (len < avail) { avail = len; } System.arraycopy(buf, pos, b, off, avail); pos += avail; off += avail; len -= avail; } if (len > 0) { len = super.read(b, off, len); if (len == -1) { return avail == 0 ? -1 : avail; } return avail + len; } return avail; } /** * Pushes back a byte by copying it to the front of the pushback buffer. * After this method returns, the next byte to be read will have the value * <code>(byte)b</code>. * * @param b the <code>int</code> value whose low-order * byte is to be pushed back. * @exception IOException If there is not enough room in the pushback * buffer for the byte. */ public void unread(int b) throws IOException { if (pos == 0) { throw new IOException("Push back buffer is full"); } buf[--pos] = (byte)b; } /** * Pushes back a portion of an array of bytes by copying it to the front * of the pushback buffer. After this method returns, the next byte to be * read will have the value <code>b[off]</code>, the byte after that will * have the value <code>b[off+1]</code>, and so forth. * * @param b the byte array to push back. * @param off the start offset of the data. * @param len the number of bytes to push back. * @exception IOException If there is not enough room in the pushback * buffer for the specified number of bytes. * @since JDK1.1 */ public void unread(byte[] b, int off, int len) throws IOException { if (len > pos) { throw new IOException("Push back buffer is full"); } pos -= len; System.arraycopy(b, off, buf, pos, len); } /** * Pushes back an array of bytes by copying it to the front of the * pushback buffer. After this method returns, the next byte to be read * will have the value <code>b[0]</code>, the byte after that will have the * value <code>b[1]</code>, and so forth. * * @param b the byte array to push back * @exception IOException If there is not enough room in the pushback * buffer for the specified number of bytes. * @since JDK1.1 */ public void unread(byte[] b) throws IOException { unread(b, 0, b.length); } /** * Returns the number of bytes that can be read from this input stream * without blocking. This method calls the <code>available</code> method * of the underlying input stream; it returns that value plus the number of * bytes that have been pushed back. * * @return the number of bytes that can be read from the input stream * without blocking. * @exception IOException if an I/O error occurs. * @see java.io.FilterInputStream#in */ public int available() throws IOException { return pos + super.available(); } /** * Tests if this input stream supports the <code>mark</code> and * <code>reset</code> methods, which it does not. * * @return <code>false</code>, since this class does not support the * <code>mark</code> and <code>reset</code> methods. * @see java.io.InputStream#mark(int) * @see java.io.InputStream#reset() */ public boolean markSupported() { return false; } }
⏎ java/io/PushbackInputStream.java
Or download all of them as a single archive file:
File name: jdk-1.1.8-src.zip File size: 1574187 bytes Release date: 2018-11-16 Download
⇒ Backup JDK 1.1 Installation Directory
2018-11-17, 175355👍, 0💬
Popular Posts:
JLayer is a library that decodes/plays/converts MPEG 1/2/2.5 Layer 1/2/3 (i.e. MP3) in real time for...
What JAR files are required to run dom\Writer.java provided in the Apache Xerces package? 3 JAR file...
xml-commons External Source Code Files are provided in the source package file, xml-commons-external...
commons-lang-1.0.1.jar is the JAR file for Apache Commons Lang 1.0.1, which provides a host of helpe...
What Is HttpComponents httpcore-4.4.6.jar? HttpComponents httpcore-4.4.6.jar is the JAR file for Apa...