FileInputStream to read from the
* specified named file. A security check is first made to determine
* whether or not access to this file is allowed. This is done by
* calling the checkRead() method of the
* SecurityManager
* (if one exists) with the name of this file. An exception is thrown
* if reading is not allowed. If the file does not exist, an exception
* is also thrown.
*
* @param name The name of the file this stream should read from
*
* @exception SecurityException If read access to the file is not allowed
* @exception FileNotFoundException If the file does not exist
* or if it is a directory
*/
public FileInputStream(String name) throws FileNotFoundException
{
this(new File(name));
}
/**
* This method initializes a FileInputStream to read from the
* specified File object. A security check is first
* made to determine
* whether or not access to this file is allowed. This is done by
* calling the checkRead() method of the
* SecurityManager
* (if one exists) with the name of this file. An exception is thrown
* if reading is not allowed. If the file does not exist, an exception
* is also thrown.
*
* @param file The File object this stream should read from
*
* @exception SecurityException If read access to the file is not allowed
* @exception FileNotFoundException If the file does not exist
* or if it is a directory.
*/
public FileInputStream(File file) throws FileNotFoundException
{
SecurityManager s = System.getSecurityManager();
if (s != null)
s.checkRead(file.getPath());
ch = FileChannelImpl.create(file, FileChannelImpl.READ);
}
/**
* This method initializes a FileInputStream to read from the
* specified FileDescriptor object. A security
* check is first made to
* determine whether or not access to this file is allowed. This is done by
* calling the checkRead() method of the
* SecurityManager
* (if one exists) with the specified FileDescriptor
* An exception is
* thrown if reading is not allowed.
*
* @param fdObj The FileDescriptor object this stream
* should read from
*
* @exception SecurityException If read access to the file is not allowed
*/
public FileInputStream(FileDescriptor fdObj)
{
SecurityManager s = System.getSecurityManager();
if (s != null)
s.checkRead(fdObj);
fd = fdObj;
ch = (FileChannelImpl) fdObj.channel;
}
FileInputStream(FileChannelImpl ch)
{
this.ch = ch;
}
/**
* This method returns the number of bytes that can be read from this
* stream before a read can block. A return of 0 indicates that blocking
* might (or might not) occur on the very next read attempt.
* * This method returns the number of unread bytes remaining in the file if * the descriptor being read from is an actual file. If this method is * reading from a ''special'' file such a the standard input, this method * will return the appropriate value for the stream being read. *
* Be aware that reads on plain files that do not reside locally might
* possibly block even if this method says they should not. For example,
* a remote server might crash, preventing an NFS mounted file from being
* read.
*
* @return The number of bytes that can be read before blocking could occur
*
* @exception IOException If an error occurs
*/
public int available() throws IOException
{
return ch.available();
}
/**
* This method closes the stream. Any futher attempts to read from the
* stream will likely generate an IOException since the underlying file
* will be closed.
*
* @exception IOException If an error occurs.
*/
public void close() throws IOException
{
ch.close();
}
protected void finalize() throws IOException
{
// We don't actually need this, but we include it because it is
// mentioned in the JCL.
}
/**
* This method returns a FileDescriptor object representing the
* underlying native file handle of the file this stream is reading
* from
*
* @return A FileDescriptor for this stream
*
* @exception IOException If an error occurs
*/
public final FileDescriptor getFD() throws IOException
{
synchronized (this)
{
if (fd == null)
fd = new FileDescriptor (ch);
return fd;
}
}
/**
* This method reads an unsigned byte from the input stream and returns it
* as an int in the range of 0-255. This method also will return -1 if
* the end of the stream has been reached.
*
* This method will block until the byte can be read. * * @return The byte read or -1 if end of stream * * @exception IOException If an error occurs */ public int read() throws IOException { return ch.read(); } /** * This method reads bytes from a stream and stores them into a caller * supplied buffer. This method attempts to completely fill the buffer, * but can return before doing so. The actual number of bytes read is * returned as an int. A -1 is returned to indicate the end of the stream. *
* This method will block until some data can be read. *
* This method operates by calling an overloaded read method like so:
* read(buf, 0, buf.length)
*
* @param buf The buffer into which the bytes read will be stored.
*
* @return The number of bytes read or -1 if end of stream.
*
* @exception IOException If an error occurs.
*/
public int read(byte[] buf) throws IOException
{
return read(buf, 0, buf.length);
}
/**
* This method read bytes from a stream and stores them into a caller
* supplied buffer. It starts storing the data at index
* offset into
* the buffer and attempts to read len bytes. This method can
* return before reading the number of bytes requested. The actual number
* of bytes read is returned as an int. A -1 is returned to indicate the
* end of the stream.
*
* This method will block until some data can be read. * * @param buf The array into which the bytes read should be stored * @param offset The offset into the array to start storing bytes * @param len The requested number of bytes to read * * @return The actual number of bytes read, or -1 if end of stream. * * @exception IOException If an error occurs. */ public int read(byte[] buf, int offset, int len) throws IOException { if (offset < 0 || len < 0 || offset + len > buf.length) throw new ArrayIndexOutOfBoundsException(); return ch.read(buf, offset, len); } /** * This method skips the specified number of bytes in the stream. It * returns the actual number of bytes skipped, which may be less than the * requested amount. *
* @param numBytes The requested number of bytes to skip * * @return The actual number of bytes skipped. * * @exception IOException If an error occurs */ public synchronized long skip (long numBytes) throws IOException { if (numBytes < 0) throw new IllegalArgumentException ("Can't skip negative bytes: " + numBytes); if (numBytes == 0) return 0; long oldPos = ch.position (); ch.position(oldPos + numBytes); return ch.position() - oldPos; } /** * This method creates a java.nio.channels.FileChannel. * Nio does not allow one to create a file channel directly. * A file channel must be created by first creating an instance of * Input/Output/RandomAccessFile and invoking the getChannel() method on it. */ public synchronized FileChannel getChannel () { return ch; } } // class FileInputStream