OpenJDK 27 · java.io.RandomAccessFile · APIdia, the JavaDoc alternative

Modifier and Type	Field and Description
private final byte[]	buffer A local buffer that allows reading and writing of longer primitive parameters (e.g. long) to be performed using bulk operations rather than on a per-byte basis.
private volatile FileChannel	channel
private volatile boolean	closed
private final Object	closeLock
private final FileDescriptor	fd
private static boolean	jfrTracing Flag set by jdk.internal.event.JFRTracing to indicate if file reads and writes should be traced by JFR.
private static final int	O_DSYNC
private static final int	O_RDONLY
private static final int	O_RDWR
private static final int	O_SYNC
private static final int	O_TEMPORARY
private final String	path The path of the referenced file (null if the stream is created with a file descriptor)
private final boolean	rw
private final boolean	sync

Access	Constructor and Description
public	RandomAccessFile(String the system-dependent pathname string pathname, String the access mode mode) Creates a random access file stream to read from, and optionally to write to, a file with the specified pathname.
public	RandomAccessFile(File the file object file, String the access mode, as described above mode) Creates a random access file stream to read from, and optionally to write to, the file specified by the `File` argument.
private	RandomAccessFile(File file, String mode, boolean openAndDelete)

Method Summary

Modifier and Type	Method and Description
public void	close() Implements java.io.Closeable.close. Closes this random access file stream and releases any system resources associated with the stream.
public final FileChannel	Returns: the file channel associated with this file getChannel() Returns the unique `FileChannel` object associated with this file.
public final FileDescriptor	Returns: the file descriptor object associated with this stream. getFD() Returns the opaque file descriptor object associated with this stream.
public native long	Returns: the offset from the beginning of the file, in bytes, at which the next read or write occurs. getFilePointer() Returns the current offset in this file.
private final String	implReadLine()
private void	implWrite(int b)
private void	implWriteBytes(byte[] b, int off, int len)
private static native void	initIDs()
public long	Returns: the length of this file, measured in bytes. length() Returns the length of this file.
private native long	length0()
private void	open(String the name of the file name, int the mode flags, a combination of the O_ constants defined above mode) Opens a file and returns the file descriptor.
private native void	open0(String the name of the file name, int the mode flags, a combination of the O_ constants defined above mode) Opens a file and returns the file descriptor.
public int	Returns: the next byte of data, or `-1` if the end of the file has been reached. read() Reads a byte of data from this file.
public int	Returns: the total number of bytes read into the buffer, or `-1` if there is no more data because the end of the file has been reached. read(byte[] the buffer into which the data is read. b, int the start offset in array `b` at which the data is written. off, int the maximum number of bytes read. len) Reads up to `len` bytes of data from this file into an array of bytes.
public int	Returns: the total number of bytes read into the buffer, or `-1` if there is no more data because the end of this file has been reached. read(byte[] the buffer into which the data is read. b) Reads up to `b.length` bytes of data from this file into an array of bytes.
private native int	read0()
public final boolean	Returns: the `boolean` value read. readBoolean() Implements java.io.DataInput.readBoolean. Reads a `boolean` from this file.
public final byte	Returns: the next byte of this file as a signed eight-bit `byte`. readByte() Implements java.io.DataInput.readByte. Reads a signed eight-bit value from this file.
private int	readBytes(byte[] the buffer into which the data is read. b, int the start offset of the data. off, int the number of bytes to read. len) Reads a sub array as a sequence of bytes.
private native int	readBytes0(byte[] b, int off, int len)
public final char	Returns: the next two bytes of this file, interpreted as a `char`. readChar() Implements java.io.DataInput.readChar. Reads a character from this file.
public final double	Returns: the next eight bytes of this file, interpreted as a `double`. readDouble() Implements java.io.DataInput.readDouble. Reads a `double` from this file.
public final float	Returns: the next four bytes of this file, interpreted as a `float`. readFloat() Implements java.io.DataInput.readFloat. Reads a `float` from this file.
public final void	readFully(byte[] the buffer into which the data is read. b) Implements java.io.DataInput.readFully. Reads `b.length` bytes from this file into the byte array, starting at the current file pointer.
public final void	readFully(byte[] the buffer into which the data is read. b, int the start offset into the data array `b`. off, int the number of bytes to read. len) Implements java.io.DataInput.readFully. Reads exactly `len` bytes from this file into the byte array, starting at the current file pointer.
public final int	Returns: the next four bytes of this file, interpreted as an `int`. readInt() Implements java.io.DataInput.readInt. Reads a signed 32-bit integer from this file.
public final String	Returns: the next line of text from this file, or null if end of file is encountered before even one byte is read. readLine() Implements java.io.DataInput.readLine. Reads the next line of text from this file.
public final long	Returns: the next eight bytes of this file, interpreted as a `long`. readLong() Implements java.io.DataInput.readLong. Reads a signed 64-bit integer from this file.
public final short	Returns: the next two bytes of this file, interpreted as a signed 16-bit number. readShort() Implements java.io.DataInput.readShort. Reads a signed 16-bit number from this file.
public final int	Returns: the next byte of this file, interpreted as an unsigned eight-bit number. readUnsignedByte() Implements java.io.DataInput.readUnsignedByte. Reads an unsigned eight-bit number from this file.
public final int	Returns: the next two bytes of this file, interpreted as an unsigned 16-bit integer. readUnsignedShort() Implements java.io.DataInput.readUnsignedShort. Reads an unsigned 16-bit number from this file.
public final String	Returns: a Unicode string. readUTF() Implements java.io.DataInput.readUTF. Reads in a string from this file.
public void	seek(long the offset position, measured in bytes from the beginning of the file, at which to set the file pointer. pos) Sets the file-pointer offset, measured from the beginning of this file, at which the next read or write occurs.
private native void	seek0(long pos)
public void	setLength(long The desired length of the file newLength) Sets the length of this file.
private native void	setLength0(long newLength)
public int	Returns: the actual number of bytes skipped. skipBytes(int the number of bytes to be skipped. n) Implements java.io.DataInput.skipBytes. Attempts to skip over `n` bytes of input discarding the skipped bytes.
private void	traceImplWrite(int b)
private void	traceImplWriteBytes(byte[] b, int off, int len)
private int	traceRead0()
private int	traceReadBytes0(byte[] b, int off, int len)
public void	write(int the `byte` to be written. b) Implements java.io.DataOutput.write. Writes the specified byte to this file.
public void	write(byte[] the data. b) Implements java.io.DataOutput.write. Writes `b.length` bytes from the specified byte array to this file, starting at the current file pointer.
public void	write(byte[] the data. b, int the start offset in the data. off, int the number of bytes to write. len) Implements java.io.DataOutput.write. Writes `len` bytes from the specified byte array starting at offset `off` to this file.
private native void	write0(int b)
public final void	writeBoolean(boolean a `boolean` value to be written. v) Implements java.io.DataOutput.writeBoolean. Writes a `boolean` to the file as a one-byte value.
public final void	writeByte(int a `byte` value to be written. v) Implements java.io.DataOutput.writeByte. Writes a `byte` to the file as a one-byte value.
private void	writeBytes(byte[] the data to be written b, int the start offset in the data off, int the number of bytes that are written len) Writes a sub array as a sequence of bytes.
public final void	writeBytes(String a string of bytes to be written. s) Implements java.io.DataOutput.writeBytes. Writes the string to the file as a sequence of bytes.
private native void	writeBytes0(byte[] b, int off, int len)
public final void	writeChar(int a `char` value to be written. v) Implements java.io.DataOutput.writeChar. Writes a `char` to the file as a two-byte value, high byte first.
public final void	writeChars(String a `String` value to be written. s) Implements java.io.DataOutput.writeChars. Writes a string to the file as a sequence of characters.
public final void	writeDouble(double a `double` value to be written. v) Implements java.io.DataOutput.writeDouble. Converts the double argument to a `long` using the `doubleToLongBits` method in class `Double`, and then writes that `long` value to the file as an eight-byte quantity, high byte first.
public final void	writeFloat(float a `float` value to be written. v) Implements java.io.DataOutput.writeFloat. Converts the float argument to an `int` using the `floatToIntBits` method in class `Float`, and then writes that `int` value to the file as a four-byte quantity, high byte first.
public final void	writeInt(int an `int` to be written. v) Implements java.io.DataOutput.writeInt. Writes an `int` to the file as four bytes, high byte first.
public final void	writeLong(long a `long` to be written. v) Implements java.io.DataOutput.writeLong. Writes a `long` to the file as eight bytes, high byte first.
public final void	writeShort(int a `short` to be written. v) Implements java.io.DataOutput.writeShort. Writes a `short` to the file as two bytes, high byte first.
public final void	writeUTF(String a string to be written. str) Implements java.io.DataOutput.writeUTF. Writes a string to the file using modified UTF-8 encoding in a machine-independent manner.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

buffer	back to summary
private final byte[] buffer A local buffer that allows reading and writing of longer primitive parameters (e.g. long) to be performed using bulk operations rather than on a per-byte basis.

channel	back to summary
private volatile FileChannel channel

closed	back to summary
private volatile boolean closed

closeLock	back to summary
private final Object closeLock

fd	back to summary
private final FileDescriptor fd

jfrTracing	back to summary
private static boolean jfrTracing Flag set by jdk.internal.event.JFRTracing to indicate if file reads and writes should be traced by JFR.

O_DSYNC	back to summary
private static final int O_DSYNC

O_RDONLY	back to summary
private static final int O_RDONLY

O_RDWR	back to summary
private static final int O_RDWR

O_SYNC	back to summary
private static final int O_SYNC

O_TEMPORARY	back to summary
private static final int O_TEMPORARY

path	back to summary
private final String path The path of the referenced file (null if the stream is created with a file descriptor)

rw	back to summary
private final boolean rw

sync	back to summary
private final boolean sync

RandomAccessFile	back to summary
public RandomAccessFile(String pathname, String mode) throws FileNotFoundException Creates a random access file stream to read from, and optionally to write to, a file with the specified pathname. If the file exists it is opened; if it does not exist and write mode is specified, a new file is created. Symbolic links are automatically redirected to the target of the link. A new `FileDescriptor` object is created to represent the connection to the file. The `mode` argument specifies the access mode with which the file is to be opened. The permitted values and their meanings are as specified for the `RandomAccessFile(File,String)` constructor. Parameters pathname:String the system-dependent pathname string mode:String the access mode Exceptions FileNotFoundException: if the mode is `"r"` but the given pathname string does not denote an existing regular file, or if the mode begins with `"rw"` but the given pathname string does not denote an existing, writable regular file and a new regular file of that pathname cannot be created, or if some other error occurs while opening or creating the file IllegalArgumentException: if the mode argument is not equal to one of `"r"`, `"rw"`, `"rws"`, or `"rwd"`

RandomAccessFile	back to summary
private RandomAccessFile(File file, String mode, boolean openAndDelete) throws FileNotFoundException

Method Detail

close	back to summary
public void close() throws IOException Implements java.io.Closeable.close. Closes this random access file stream and releases any system resources associated with the stream. A closed random access file cannot perform input or output operations and cannot be reopened. If this file has an associated channel then the channel is closed as well. API Note If this stream has an associated channel then this method will close the channel, which in turn will close this stream. Subclasses that override this method should be prepared to handle possible reentrant invocation. Exceptions IOException: if an I/O error occurs.

back to summary

public void close() throws IOException

Implements java.io.Closeable.close.

Closes this random access file stream and releases any system resources associated with the stream. A closed random access file cannot perform input or output operations and cannot be reopened.

If this file has an associated channel then the channel is closed as well.

API Note

If this stream has an associated channel then this method will close the channel, which in turn will close this stream. Subclasses that override this method should be prepared to handle possible reentrant invocation.

Exceptions

IOException:: if an I/O error occurs.

getChannel back to summary

getChannel	back to summary
public final FileChannel getChannel() Returns the unique `FileChannel` object associated with this file. The `position` of the returned channel will always be equal to this object's file-pointer offset as returned by the `getFilePointer` method. Changing this object's file-pointer offset, whether explicitly or by reading or writing bytes, will change the position of the channel, and vice versa. Changing the file's length via this object will change the length seen via the file channel, and vice versa. Returns:FileChannel the file channel associated with this file Since 1.4

public final FileChannel getChannel()

Returns the unique FileChannel object associated with this file.

The position of the returned channel will always be equal to this object's file-pointer offset as returned by the getFilePointer method. Changing this object's file-pointer offset, whether explicitly or by reading or writing bytes, will change the position of the channel, and vice versa. Changing the file's length via this object will change the length seen via the file channel, and vice versa.

Returns:FileChannel: the file channel associated with this file
Since: 1.4

getFD back to summary

getFD	back to summary
public final FileDescriptor getFD() throws IOException Returns the opaque file descriptor object associated with this stream. Returns:FileDescriptor the file descriptor object associated with this stream. Exceptions IOException: if an I/O error occurs. See Also `java.io.FileDescriptor`

public final FileDescriptor getFD() throws IOException

Returns the opaque file descriptor object associated with this stream.

Returns:FileDescriptor

the file descriptor object associated with this stream.

Exceptions

IOException:: if an I/O error occurs.

See Also

java.io.FileDescriptor

getFilePointer	back to summary
public native long getFilePointer() throws IOException Returns the current offset in this file. Returns:long the offset from the beginning of the file, in bytes, at which the next read or write occurs. Exceptions IOException: if an I/O error occurs.

getFilePointer

back to summary

public native long getFilePointer() throws IOException

Returns the current offset in this file.

Returns:long

the offset from the beginning of the file, in bytes, at which the next read or write occurs.

Exceptions

IOException:: if an I/O error occurs.

implReadLine	back to summary
private final String implReadLine() throws IOException

implWrite	back to summary
private void implWrite(int b) throws IOException

implWriteBytes	back to summary
private void implWriteBytes(byte[] b, int off, int len) throws IOException

initIDs	back to summary
private static native void initIDs()

length	back to summary
public long length() throws IOException Returns the length of this file. Returns:long the length of this file, measured in bytes. Exceptions IOException: if an I/O error occurs.

length

back to summary

public long length() throws IOException

Returns the length of this file.

Returns:long

the length of this file, measured in bytes.

Exceptions

IOException:: if an I/O error occurs.

length0	back to summary
private native long length0() throws IOException

open back to summary

open	back to summary
private void open(String name, int mode) throws FileNotFoundException Opens a file and returns the file descriptor. The file is opened in read-write mode if the O_RDWR bit in `mode` is true, else the file is opened as read-only. If the `name` refers to a directory, an IOException is thrown. Parameters name:String the name of the file mode:int the mode flags, a combination of the O_ constants defined above

private void open(String name, int mode) throws FileNotFoundException

Opens a file and returns the file descriptor. The file is opened in read-write mode if the O_RDWR bit in mode is true, else the file is opened as read-only. If the name refers to a directory, an IOException is thrown.

Parameters

name:String: the name of the file
mode:int: the mode flags, a combination of the O_ constants defined above

open0 back to summary

open0	back to summary
private native void open0(String name, int mode) throws FileNotFoundException Opens a file and returns the file descriptor. The file is opened in read-write mode if the O_RDWR bit in `mode` is true, else the file is opened as read-only. If the `name` refers to a directory, an IOException is thrown. Parameters name:String the name of the file mode:int the mode flags, a combination of the O_ constants defined above

private native void open0(String name, int mode) throws FileNotFoundException

Parameters

name:String: the name of the file
mode:int: the mode flags, a combination of the O_ constants defined above

read back to summary

read	back to summary
public int read() throws IOException Reads a byte of data from this file. The byte is returned as an integer in the range 0 to 255 (`0x00-0x0ff`). This method blocks if no input is yet available. Although `RandomAccessFile` is not a subclass of `InputStream`, this method behaves in exactly the same way as the `InputStream#read()` method of `InputStream`. Returns:int the next byte of data, or `-1` if the end of the file has been reached. Exceptions IOException: if an I/O error occurs. Not thrown if end-of-file has been reached.

public int read() throws IOException

Reads a byte of data from this file. The byte is returned as an integer in the range 0 to 255 (0x00-0x0ff). This method blocks if no input is yet available.

Although RandomAccessFile is not a subclass of InputStream, this method behaves in exactly the same way as the InputStream#read() method of InputStream.

Returns:int

the next byte of data, or -1 if the end of the file has been reached.

Exceptions

IOException:: if an I/O error occurs. Not thrown if end-of-file has been reached.

read back to summary

read	back to summary
public int read(byte[] b, int off, int len) throws IOException Reads up to `len` bytes of data from this file into an array of bytes. This method blocks until at least one byte of input is available. Although `RandomAccessFile` is not a subclass of `InputStream`, this method behaves in exactly the same way as the `InputStream#read(byte[], int, int)` method of `InputStream`. Parameters b:byte[] the buffer into which the data is read. off:int the start offset in array `b` at which the data is written. len:int the maximum number of bytes read. Returns:int the total number of bytes read into the buffer, or `-1` if there is no more data because the end of the file has been reached. Exceptions IOException: If the first byte cannot be read for any reason other than end of file, or if the random access file has been closed, or if some other I/O error occurs. NullPointerException: If `b` is `null`. IndexOutOfBoundsException: If `off` is negative, `len` is negative, or `len` is greater than `b.length - off`

public int read(byte[] b, int off, int len) throws IOException

Reads up to len bytes of data from this file into an array of bytes. This method blocks until at least one byte of input is available.

Although RandomAccessFile is not a subclass of InputStream, this method behaves in exactly the same way as the InputStream#read(byte[], int, int) method of InputStream.

Parameters

b:byte[]: the buffer into which the data is read.
off:int: the start offset in array b at which the data is written.
len:int: the maximum number of bytes read.

Returns:int

the total number of bytes read into the buffer, or -1 if there is no more data because the end of the file has been reached.

Exceptions

IOException:: If the first byte cannot be read for any reason other than end of file, or if the random access file has been closed, or if some other I/O error occurs.
NullPointerException:: If b is null.
IndexOutOfBoundsException:: If off is negative, len is negative, or len is greater than b.length - off

read back to summary

read	back to summary
public int read(byte[] b) throws IOException Reads up to `b.length` bytes of data from this file into an array of bytes. This method blocks until at least one byte of input is available. Although `RandomAccessFile` is not a subclass of `InputStream`, this method behaves in exactly the same way as the `InputStream#read(byte[])` method of `InputStream`. Parameters b:byte[] the buffer into which the data is read. Returns:int the total number of bytes read into the buffer, or `-1` if there is no more data because the end of this file has been reached. Exceptions IOException: If the first byte cannot be read for any reason other than end of file, or if the random access file has been closed, or if some other I/O error occurs. NullPointerException: If `b` is `null`.

public int read(byte[] b) throws IOException

Reads up to b.length bytes of data from this file into an array of bytes. This method blocks until at least one byte of input is available.

Although RandomAccessFile is not a subclass of InputStream, this method behaves in exactly the same way as the InputStream#read(byte[]) method of InputStream.

Parameters

b:byte[]: the buffer into which the data is read.

Returns:int

the total number of bytes read into the buffer, or -1 if there is no more data because the end of this file has been reached.

Exceptions

IOException:: If the first byte cannot be read for any reason other than end of file, or if the random access file has been closed, or if some other I/O error occurs.
NullPointerException:: If b is null.

read0	back to summary
private native int read0() throws IOException

readBoolean back to summary

readBoolean	back to summary
public final boolean readBoolean() throws IOException Implements java.io.DataInput.readBoolean. Reads a `boolean` from this file. This method reads a single byte from the file, starting at the current file pointer. A value of `0` represents `false`. Any other value represents `true`. This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown. Returns:boolean the `boolean` value read. Exceptions IOException: if an I/O error occurs. EOFException: if this file has reached the end.

public final boolean readBoolean() throws IOException

Implements java.io.DataInput.readBoolean.

Reads a boolean from this file. This method reads a single byte from the file, starting at the current file pointer. A value of 0 represents false. Any other value represents true. This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown.

Returns:boolean

the boolean value read.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file has reached the end.

readByte back to summary

readByte	back to summary
public final byte readByte() throws IOException Implements java.io.DataInput.readByte. Reads a signed eight-bit value from this file. This method reads a byte from the file, starting from the current file pointer. If the byte read is `b`, where `0 <= b <= 255`, then the result is: `(byte)(b)` (byte)(b) This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown. Returns:byte the next byte of this file as a signed eight-bit `byte`. Exceptions IOException: if an I/O error occurs. EOFException: if this file has reached the end.

public final byte readByte() throws IOException

Implements java.io.DataInput.readByte.

Reads a signed eight-bit value from this file. This method reads a byte from the file, starting from the current file pointer. If the byte read is b, where 0 <= b <= 255, then the result is:

(byte)(b)

This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown.

Returns:byte

the next byte of this file as a signed eight-bit byte.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file has reached the end.

readBytes	back to summary
private int readBytes(byte[] b, int off, int len) throws IOException Reads a sub array as a sequence of bytes. Parameters b:byte[] the buffer into which the data is read. off:int the start offset of the data. len:int the number of bytes to read. Exceptions IOException: If an I/O error has occurred.

readBytes

back to summary

private int readBytes(byte[] b, int off, int len) throws IOException

Reads a sub array as a sequence of bytes.

Parameters

b:byte[]: the buffer into which the data is read.
off:int: the start offset of the data.
len:int: the number of bytes to read.

Exceptions

IOException:: If an I/O error has occurred.

readBytes0	back to summary
private native int readBytes0(byte[] b, int off, int len) throws IOException

readChar back to summary

readChar	back to summary
public final char readChar() throws IOException Implements java.io.DataInput.readChar. Reads a character from this file. This method reads two bytes from the file, starting at the current file pointer. If the bytes read, in order, are `b1` and `b2`, where `0 <= b1, b2 <= 255`, then the result is equal to: `(char)((b1 << 8) \| b2)` (char)((b1 << 8) \| b2) This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown. Returns:char the next two bytes of this file, interpreted as a `char`. Exceptions IOException: if an I/O error occurs. EOFException: if this file reaches the end before reading two bytes.

public final char readChar() throws IOException

Implements java.io.DataInput.readChar.

Reads a character from this file. This method reads two bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1 and b2, where 0 <= b1, b2 <= 255, then the result is equal to:

(char)((b1 << 8) | b2)

This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown.

Returns:char

the next two bytes of this file, interpreted as a char.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file reaches the end before reading two bytes.

readDouble back to summary

readDouble	back to summary
public final double readDouble() throws IOException Implements java.io.DataInput.readDouble. Reads a `double` from this file. This method reads a `long` value, starting at the current file pointer, as if by the `readLong` method and then converts that `long` to a `double` using the `longBitsToDouble` method in class `Double`. This method blocks until the eight bytes are read, the end of the stream is detected, or an exception is thrown. Returns:double the next eight bytes of this file, interpreted as a `double`. Exceptions IOException: if an I/O error occurs. EOFException: if this file reaches the end before reading eight bytes. See Also `java.io.RandomAccessFile#readLong()`, `java.lang.Double#longBitsToDouble(long)`

public final double readDouble() throws IOException

Implements java.io.DataInput.readDouble.

Reads a double from this file. This method reads a long value, starting at the current file pointer, as if by the readLong method and then converts that long to a double using the longBitsToDouble method in class Double.

This method blocks until the eight bytes are read, the end of the stream is detected, or an exception is thrown.

Returns:double

the next eight bytes of this file, interpreted as a double.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file reaches the end before reading eight bytes.

readFloat back to summary

readFloat	back to summary
public final float readFloat() throws IOException Implements java.io.DataInput.readFloat. Reads a `float` from this file. This method reads an `int` value, starting at the current file pointer, as if by the `readInt` method and then converts that `int` to a `float` using the `intBitsToFloat` method in class `Float`. This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown. Returns:float the next four bytes of this file, interpreted as a `float`. Exceptions IOException: if an I/O error occurs. EOFException: if this file reaches the end before reading four bytes. See Also `java.io.RandomAccessFile#readInt()`, `java.lang.Float#intBitsToFloat(int)`

public final float readFloat() throws IOException

Implements java.io.DataInput.readFloat.

Reads a float from this file. This method reads an int value, starting at the current file pointer, as if by the readInt method and then converts that int to a float using the intBitsToFloat method in class Float.

This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown.

Returns:float

the next four bytes of this file, interpreted as a float.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file reaches the end before reading four bytes.

readFully back to summary

readFully	back to summary
public final void readFully(byte[] b) throws IOException Implements java.io.DataInput.readFully. Reads `b.length` bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown. Parameters b:byte[] the buffer into which the data is read. Exceptions IOException: if an I/O error occurs. NullPointerException: if `b` is `null`. EOFException: if this file reaches the end before reading all the bytes.

public final void readFully(byte[] b) throws IOException

Implements java.io.DataInput.readFully.

Reads b.length bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown.

Parameters

b:byte[]: the buffer into which the data is read.

Exceptions

IOException:: if an I/O error occurs.
NullPointerException:: if b is null.
EOFException:: if this file reaches the end before reading all the bytes.

readFully back to summary

readFully	back to summary
public final void readFully(byte[] b, int off, int len) throws IOException Implements java.io.DataInput.readFully. Reads exactly `len` bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown. Parameters b:byte[] the buffer into which the data is read. off:int the start offset into the data array `b`. len:int the number of bytes to read. Exceptions IOException: if an I/O error occurs. NullPointerException: if `b` is `null`. IndexOutOfBoundsException: if `off` is negative, `len` is negative, or `len` is greater than `b.length - off`. EOFException: if this file reaches the end before reading all the bytes.

public final void readFully(byte[] b, int off, int len) throws IOException

Implements java.io.DataInput.readFully.

Reads exactly len bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown.

Parameters

b:byte[]: the buffer into which the data is read.
off:int: the start offset into the data array b.
len:int: the number of bytes to read.

Exceptions

IOException:: if an I/O error occurs.
NullPointerException:: if b is null.
IndexOutOfBoundsException:: if off is negative, len is negative, or len is greater than b.length - off.
EOFException:: if this file reaches the end before reading all the bytes.

readInt back to summary

readInt	back to summary
public final int readInt() throws IOException Implements java.io.DataInput.readInt. Reads a signed 32-bit integer from this file. This method reads 4 bytes from the file, starting at the current file pointer. If the bytes read, in order, are `b1`, `b2`, `b3`, and `b4`, where `0 <= b1, b2, b3, b4 <= 255`, then the result is equal to: `(b1 << 24) \| (b2 << 16) + (b3 << 8) + b4` (b1 << 24) \| (b2 << 16) + (b3 << 8) + b4 This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown. Returns:int the next four bytes of this file, interpreted as an `int`. Exceptions IOException: if an I/O error occurs. EOFException: if this file reaches the end before reading four bytes.

public final int readInt() throws IOException

Implements java.io.DataInput.readInt.

Reads a signed 32-bit integer from this file. This method reads 4 bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1, b2, b3, and b4, where 0 <= b1, b2, b3, b4 <= 255, then the result is equal to:

(b1 << 24) | (b2 << 16) + (b3 << 8) + b4

This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown.

Returns:int

the next four bytes of this file, interpreted as an int.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file reaches the end before reading four bytes.

readLine back to summary

readLine	back to summary
public final String readLine() throws IOException Implements java.io.DataInput.readLine. Reads the next line of text from this file. This method successively reads bytes from the file, starting at the current file pointer, until it reaches a line terminator or the end of the file. Each byte is converted into a character by taking the byte's value for the lower eight bits of the character and setting the high eight bits of the character to zero. This method does not, therefore, support the full Unicode character set. A line of text is terminated by a carriage-return character (`'\r'`), a newline character (`'\n'`), a carriage-return character immediately followed by a newline character, or the end of the file. Line-terminating characters are discarded and are not included as part of the string returned. This method blocks until a newline character is read, a carriage return and the byte following it are read (to see if it is a newline), the end of the file is reached, or an exception is thrown. Returns:String the next line of text from this file, or null if end of file is encountered before even one byte is read. Exceptions IOException: if an I/O error occurs.

public final String readLine() throws IOException

Implements java.io.DataInput.readLine.

Reads the next line of text from this file. This method successively reads bytes from the file, starting at the current file pointer, until it reaches a line terminator or the end of the file. Each byte is converted into a character by taking the byte's value for the lower eight bits of the character and setting the high eight bits of the character to zero. This method does not, therefore, support the full Unicode character set.

A line of text is terminated by a carriage-return character ('\r'), a newline character ('\n'), a carriage-return character immediately followed by a newline character, or the end of the file. Line-terminating characters are discarded and are not included as part of the string returned.

This method blocks until a newline character is read, a carriage return and the byte following it are read (to see if it is a newline), the end of the file is reached, or an exception is thrown.

Returns:String

the next line of text from this file, or null if end of file is encountered before even one byte is read.

Exceptions

IOException:: if an I/O error occurs.

readLong back to summary

readLong	back to summary
public final long readLong() throws IOException Implements java.io.DataInput.readLong. Reads a signed 64-bit integer from this file. This method reads eight bytes from the file, starting at the current file pointer. If the bytes read, in order, are `b1`, `b2`, `b3`, `b4`, `b5`, `b6`, `b7`, and `b8,` where: `0 <= b1, b2, b3, b4, b5, b6, b7, b8 <= 255` 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <= 255 then the result is equal to: `((long)b1 << 56) + ((long)b2 << 48) + ((long)b3 << 40) + ((long)b4 << 32) + ((long)b5 << 24) + ((long)b6 << 16) + ((long)b7 << 8) + b8` ((long)b1 << 56) + ((long)b2 << 48) + ((long)b3 << 40) + ((long)b4 << 32) + ((long)b5 << 24) + ((long)b6 << 16) + ((long)b7 << 8) + b8 This method blocks until the eight bytes are read, the end of the stream is detected, or an exception is thrown. Returns:long the next eight bytes of this file, interpreted as a `long`. Exceptions IOException: if an I/O error occurs. EOFException: if this file reaches the end before reading eight bytes.

public final long readLong() throws IOException

Implements java.io.DataInput.readLong.

Reads a signed 64-bit integer from this file. This method reads eight bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1, b2, b3, b4, b5, b6, b7, and b8, where:

0 <= b1, b2, b3, b4, b5, b6, b7, b8 <= 255

then the result is equal to:

((long)b1 << 56) + ((long)b2 << 48)
    + ((long)b3 << 40) + ((long)b4 << 32)
    + ((long)b5 << 24) + ((long)b6 << 16)
    + ((long)b7 << 8) + b8

This method blocks until the eight bytes are read, the end of the stream is detected, or an exception is thrown.

Returns:long

the next eight bytes of this file, interpreted as a long.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file reaches the end before reading eight bytes.

readShort back to summary

readShort	back to summary
public final short readShort() throws IOException Implements java.io.DataInput.readShort. Reads a signed 16-bit number from this file. The method reads two bytes from this file, starting at the current file pointer. If the two bytes read, in order, are `b1` and `b2`, where each of the two values is between `0` and `255`, inclusive, then the result is equal to: `(short)((b1 << 8) \| b2)` (short)((b1 << 8) \| b2) This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown. Returns:short the next two bytes of this file, interpreted as a signed 16-bit number. Exceptions IOException: if an I/O error occurs. EOFException: if this file reaches the end before reading two bytes.

public final short readShort() throws IOException

Implements java.io.DataInput.readShort.

Reads a signed 16-bit number from this file. The method reads two bytes from this file, starting at the current file pointer. If the two bytes read, in order, are b1 and b2, where each of the two values is between 0 and 255, inclusive, then the result is equal to:

(short)((b1 << 8) | b2)

This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown.

Returns:short

the next two bytes of this file, interpreted as a signed 16-bit number.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file reaches the end before reading two bytes.

readUnsignedByte

back to summary

public final int readUnsignedByte() throws IOException

Implements java.io.DataInput.readUnsignedByte.

Reads an unsigned eight-bit number from this file. This method reads a byte from this file, starting at the current file pointer, and returns that byte.

This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown.

Returns:int

the next byte of this file, interpreted as an unsigned eight-bit number.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file has reached the end.

readUnsignedShort back to summary

public final int readUnsignedShort() throws IOException

Implements java.io.DataInput.readUnsignedShort.

Reads an unsigned 16-bit number from this file. This method reads two bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1 and b2, where 0 <= b1, b2 <= 255, then the result is equal to:

(b1 << 8) | b2

This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown.

Returns:int

the next two bytes of this file, interpreted as an unsigned 16-bit integer.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file reaches the end before reading two bytes.

readUTF back to summary

public final String readUTF() throws IOException

Implements java.io.DataInput.readUTF.

Reads in a string from this file. The string has been encoded using a modified UTF-8 format.

The first two bytes are read, starting from the current file pointer, as if by readUnsignedShort. This value gives the number of following bytes that are in the encoded string, not the length of the resulting string. The following bytes are then interpreted as bytes encoding characters in the modified UTF-8 format and are converted into characters.

This method blocks until all the bytes are read, the end of the stream is detected, or an exception is thrown.

Returns:String

a Unicode string.

Exceptions

IOException:: if an I/O error occurs.
EOFException:: if this file reaches the end before reading all the bytes.
UTFDataFormatException:: if the bytes do not represent valid modified UTF-8 encoding of a Unicode string.

seek back to summary

public void seek(long pos) throws IOException

Sets the file-pointer offset, measured from the beginning of this file, at which the next read or write occurs. The offset may be set beyond the end of the file. Setting the offset beyond the end of the file does not change the file length. The file length will change only by writing after the offset has been set beyond the end of the file.

Parameters

pos:long: the offset position, measured in bytes from the beginning of the file, at which to set the file pointer.

Exceptions

IOException:: if pos is less than 0 or if an I/O error occurs.

seek0	back to summary
private native void seek0(long pos) throws IOException

setLength back to summary

public void setLength(long newLength) throws IOException

Sets the length of this file.

If the present length of the file as returned by the length method is greater than the desired length of the file specified by the newLength argument, then the file will be truncated.

If the present length of the file is smaller than the desired length, then the file will be extended. The contents of the extended portion of the file are not defined.

If the present length of the file is equal to the desired length, then the file and its length will be unchanged.

In all cases, after this method returns, the file offset as returned by the getFilePointer method will equal the minimum of the desired length and the file offset before this method was called, even if the length is unchanged. In other words, this method constrains the file offset to the closed interval [0,newLength].

Parameters

newLength:long: The desired length of the file

Exceptions

IOException:: If the argument is negative or if some other I/O error occurs

Since

1.2

setLength0	back to summary
private native void setLength0(long newLength) throws IOException

skipBytes back to summary

public int skipBytes(int n) throws IOException

Implements java.io.DataInput.skipBytes.

Attempts to skip over n bytes of input discarding the skipped bytes.

This method may skip over some smaller number of bytes, possibly zero. This may result from any of a number of conditions; reaching end of file before n bytes have been skipped is only one possibility. This method never throws an EOFException. The actual number of bytes skipped is returned. If n is negative, no bytes are skipped.

Parameters

n:int: the number of bytes to be skipped.

Returns:int

the actual number of bytes skipped.

Exceptions

IOException:: if an I/O error occurs.

traceImplWrite	back to summary
private void traceImplWrite(int b) throws IOException

traceImplWriteBytes	back to summary
private void traceImplWriteBytes(byte[] b, int off, int len) throws IOException

traceRead0	back to summary
private int traceRead0() throws IOException

traceReadBytes0	back to summary
private int traceReadBytes0(byte[] b, int off, int len) throws IOException

write back to summary

public void write(int b) throws IOException

Implements java.io.DataOutput.write.

Writes the specified byte to this file. The write starts at the current file pointer.

Parameters

b:int: the byte to be written.

Exceptions

IOException:: if an I/O error occurs.

write back to summary

public void write(byte[] b) throws IOException

Implements java.io.DataOutput.write.

Writes b.length bytes from the specified byte array to this file, starting at the current file pointer.

Parameters

b:byte[]: the data.

Exceptions

IOException:: if an I/O error occurs.

write back to summary

public void write(byte[] b, int off, int len) throws IOException

Implements java.io.DataOutput.write.

Writes len bytes from the specified byte array starting at offset off to this file.

Parameters

b:byte[]: the data.
off:int: the start offset in the data.
len:int: the number of bytes to write.

Exceptions

IOException:: if an I/O error occurs.
IndexOutOfBoundsException:: If off is negative, len is negative, or len is greater than b.length - off

write0	back to summary
private native void write0(int b) throws IOException

writeBoolean back to summary

public final void writeBoolean(boolean v) throws IOException

Implements java.io.DataOutput.writeBoolean.

Writes a boolean to the file as a one-byte value. The value true is written out as the value (byte)1; the value false is written out as the value (byte)0. The write starts at the current position of the file pointer.

Parameters

v:boolean: a boolean value to be written.

Exceptions

IOException:: if an I/O error occurs.

writeByte back to summary

public final void writeByte(int v) throws IOException

Implements java.io.DataOutput.writeByte.

Writes a byte to the file as a one-byte value. The write starts at the current position of the file pointer.

Parameters

v:int: a byte value to be written.

Exceptions

IOException:: if an I/O error occurs.

writeBytes

back to summary

private void writeBytes(byte[] b, int off, int len) throws IOException

Writes a sub array as a sequence of bytes.

Parameters

b:byte[]: the data to be written
off:int: the start offset in the data
len:int: the number of bytes that are written

Exceptions

IOException:: If an I/O error has occurred.

writeBytes

back to summary

public final void writeBytes(String s) throws IOException

Implements java.io.DataOutput.writeBytes.

Writes the string to the file as a sequence of bytes. Each character in the string is written out, in sequence, by discarding its high eight bits. The write starts at the current position of the file pointer.

Parameters

s:String: a string of bytes to be written.

Annotations

@SuppressWarnings:deprecation

Exceptions

IOException:: if an I/O error occurs.

writeBytes0	back to summary
private native void writeBytes0(byte[] b, int off, int len) throws IOException

writeChar back to summary

public final void writeChar(int v) throws IOException

Implements java.io.DataOutput.writeChar.

Writes a char to the file as a two-byte value, high byte first. The write starts at the current position of the file pointer.

Parameters

v:int: a char value to be written.

Exceptions

IOException:: if an I/O error occurs.

writeChars back to summary

public final void writeChars(String s) throws IOException

Implements java.io.DataOutput.writeChars.

Writes a string to the file as a sequence of characters. Each character is written to the data output stream as if by the writeChar method. The write starts at the current position of the file pointer.

Parameters

s:String: a String value to be written.

Exceptions

IOException:: if an I/O error occurs.

writeDouble back to summary

public final void writeDouble(double v) throws IOException

Implements java.io.DataOutput.writeDouble.

Converts the double argument to a long using the doubleToLongBits method in class Double, and then writes that long value to the file as an eight-byte quantity, high byte first. The write starts at the current position of the file pointer.

Parameters

v:double: a double value to be written.

Exceptions

IOException:: if an I/O error occurs.

writeFloat back to summary

public final void writeFloat(float v) throws IOException

Implements java.io.DataOutput.writeFloat.

Converts the float argument to an int using the floatToIntBits method in class Float, and then writes that int value to the file as a four-byte quantity, high byte first. The write starts at the current position of the file pointer.

Parameters

v:float: a float value to be written.

Exceptions

IOException:: if an I/O error occurs.

See Also

java.lang.Float#floatToIntBits(float)

writeInt back to summary

public final void writeInt(int v) throws IOException

Implements java.io.DataOutput.writeInt.

Writes an int to the file as four bytes, high byte first. The write starts at the current position of the file pointer.

Parameters

v:int: an int to be written.

Exceptions

IOException:: if an I/O error occurs.

writeLong back to summary

public final void writeLong(long v) throws IOException

Implements java.io.DataOutput.writeLong.

Writes a long to the file as eight bytes, high byte first. The write starts at the current position of the file pointer.

Parameters

v:long: a long to be written.

Exceptions

IOException:: if an I/O error occurs.

writeShort back to summary

public final void writeShort(int v) throws IOException

Implements java.io.DataOutput.writeShort.

Writes a short to the file as two bytes, high byte first. The write starts at the current position of the file pointer.

Parameters

v:int: a short to be written.

Exceptions

IOException:: if an I/O error occurs.

writeUTF back to summary

public final void writeUTF(String str) throws IOException

Implements java.io.DataOutput.writeUTF.

Writes a string to the file using modified UTF-8 encoding in a machine-independent manner.

First, two bytes are written to the file, starting at the current file pointer, as if by the writeShort method giving the number of bytes to follow. This value is the number of bytes actually written out, not the length of the string. Following the length, each character of the string is output, in sequence, using the modified UTF-8 encoding for each character.

Parameters

str:String: a string to be written.

Exceptions

IOException:: if an I/O error occurs.

public Class RandomAccessFile

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail