Java IO.pdf - Nguyen Dang Binh

Chapter 4. File Streams
Java I/O
Until now, most of the examples in this book have used the streams System.in and
System.out. These are convenient for examples, but in real life, you'll more commonly attach
streams to data sources like files and network connections. You'll use the
java.io.FileInputStream and java.io.FileOutputStream classes, which are concrete
subclasses of java.io.InputStream and java.io.OutputStream, to read and write files.
FileInputStream and FileOutputStream provide input and output streams that let you read
and write files. We'll discuss these classes in detail in this chapter; they provide the standard
methods for reading and writing data. What they don't provide is a mechanism for filespecific
operations, like finding out whether a file is readable or writable. For that, you may
want to look forward to Chapter 12, which talks about the File class itself and the way Java
works with files.
4.1 Reading Files
java.io.FileInputStream is a concrete subclass of java.io.InputStream. It provides an
input stream connected to a particular file.
public class FileInputStream extends InputStream
FileInputStream has all the usual methods of input streams, such as read(), available(),
skip(), and close(), which are used exactly as they are for any other input stream.
public native int read() throws IOException
public int read(byte[] data) throws IOException
public int read(byte[] data, int offset, int length) throws IOException
public native long skip(long n) throws IOException
public native int available() throws IOException
public native void close() throws IOException
These methods are all implemented in native code, except for the two multibyte read()
methods. These, however, just pass their arguments on to a private native method called
readBytes(), so effectively all these methods are implemented with native code. (In Java 2,
read(byte[] data, int offset, int length) is a native method that read(byte[] data)
invokes.)
There are three FileInputStream() constructors, which differ only in how the file to be read
is specified:
public FileInputStream(String fileName) throws IOException
public FileInputStream(File file) throws FileNotFoundException
public FileInputStream(FileDescriptor fdObj)
The first constructor uses a string containing the name of the file. The second constructor uses
a java.io.File object. The third constructor uses a java.io.FileDescriptor object.
Filenames are platform-dependent, so hardcoded file names should be avoided where
possible. Using the first constructor violates Sun's rules for "100% Pure Java" immediately.
Therefore, the second two constructors are much preferred. Nonetheless, the second two will
have to wait until File objects and file descriptors are discussed in Chapter 12. For now, I
will use only the first.
51