Java IO.pdf - Nguyen Dang Binh

Java I/O
Since file descriptors are only associated with open files and sockets, they become invalid as
soon as the file or socket is closed. You can test whether a file descriptor is still valid with the
valid() method:
public native boolean valid()
This returns true if the descriptor is still valid, false if it isn't.
The one real use to which a client programmer can put a file descriptor object is to sync a file.
This is accomplished with the aptly named sync() method:
public native void sync() throws SyncFailedException
The sync() method forces the system buffers to write all the data they contain to the actual
hardware. Generally, you'll want to flush the stream before syncing it. Flushing clears out
Java's internal buffers. Syncing clears out the operating system's, device driver's, and
hardware's buffers. If synchronization does not succeed, then sync() throws a
java.io.SyncFailedException, a subclass of IOException.
12.7 Random-Access Files
File input and output streams require you to start reading or writing at the beginning of a file
and then read or write the file in order, possibly skipping over some bytes or backing up but
more or less moving from start to finish. Sometimes, however, you need to read parts of a file
in a more or less random order, where the data near the beginning of the file isn't necessarily
read before the data nearer the end. Other times you need to both read and write the same file.
For example, in record-oriented applications like databases, the actual data may be indexed;
you would use the index to determine where in the file to find the record you need to read or
write. While you could do this by constantly opening and closing the file and skipping to the
point where you needed to read, this is far from efficient. Writes are even worse, since you
would need to read and rewrite the entire file, even to change just one byte of data.
Random-access files can be read from or written to or both from a particular byte position in
the file. A single random-access file can be both read and written without first being closed.
The position in the file where reads and writes start from is indicated by an integer called the
file pointer. Each read or write advances the file pointer by the number of bytes read or
written. Furthermore, the programmer can reposition the file pointer at different bytes in the
file without closing the file.
In Java, random file access is performed through the java.io.RandomAccessFile class. This
is not a subclass of java.io.File:
public class RandomAccessFile extends Object implements DataInput,
DataOutput
Among other differences between File objects and RandomAccessFile objects, the
RandomAccessFile constructors actually open the file in question and throw an IOException
if it doesn't exist:
public RandomAccessFile(String filename, String mode) throws
FileNotFoundException
302