RandomAccessFile (Java 2 Platform SE 6)
<META NAME="keywords" CONTENT="概述, JavaTM 2 Platform Standard Edition 6API 开发人员文档">
JavaTM&2&PlatformStandard&Ed. 6
类 RandomAccessFile
java.io.RandomAccessFile
所有已实现的接口： , ,
public class RandomAccessFileextends implements , ,
此类的实例支持对随机访问文件的读取和写入。随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。存在指向该隐含数组的光标或索引，称为文件指针；输入操作从文件指针开始读取字节，并随着对字节的读取而前移此文件指针。如果随机访问文件以读取/写入模式创建，则输出操作也可用；输出操作从文件指针开始写入字节，并随着对字节的写入而前移此文件指针。写入隐含数组的当前末尾之后的输出操作导致该数组扩展。该文件指针可以通过 getFilePointer 方法读取，并通过 seek 方法设置。
通常，如果此类中的所有读取例程在读取所需数量的字节之前已到达文件末尾，则抛出 EOFException（是一种 IOException）。如果由于某些原因无法读取任何字节，而不是在读取所需数量的字节之前已到达文件末尾，则抛出 IOException，而不是 EOFException。需要特别指出的是，如果流已被关闭，则可能抛出 IOException。
从以下版本开始：
&&&&&&&&&&创建从中读取和向其中写入（可选）的随机访问文件流，该文件由
参数指定。
&&&&&&&&&&创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。
&&&&&&&&&&关闭此随机访问文件流并释放与该流关联的所有系统资源。
&&&&&&&&&&返回与此文件关联的唯一
&&&&&&&&&&返回与此流关联的不透明文件描述符对象。
&&&&&&&&&&返回此文件中的当前偏移量。
&&&&&&&&&&返回此文件的长度。
&&&&&&&&&&从此文件中读取一个数据字节。
(byte[]&b)
&&&&&&&&&&将最多 b.length 个数据字节从此文件读入 byte 数组。
(byte[]&b,
&&&&&&&&&&将最多 len 个数据字节从此文件读入 byte 数组。
&&&&&&&&&&从此文件读取一个 boolean。
&&&&&&&&&&从此文件读取一个有符号的八位值。
&&&&&&&&&&从此文件读取一个字符。
&&&&&&&&&&从此文件读取一个 double。
&&&&&&&&&&从此文件读取一个 float。
(byte[]&b)
&&&&&&&&&&将 b.length 个字节从此文件读入 byte 数组，并从当前文件指针开始。
(byte[]&b,
&&&&&&&&&&将正好 len 个字节从此文件读入 byte 数组，并从当前文件指针开始。
&&&&&&&&&&从此文件读取一个有符号的 32 位整数。
&&&&&&&&&&从此文件读取文本的下一行。
&&&&&&&&&&从此文件读取一个有符号的 64 位整数。
&&&&&&&&&&从此文件读取一个有符号的 16 位数。
&&&&&&&&&&从此文件读取一个无符号的八位数。
&&&&&&&&&&从此文件读取一个无符号的 16 位数。
&&&&&&&&&&从此文件读取一个字符串。
(long&pos)
&&&&&&&&&&设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
(long&newLength)
&&&&&&&&&&设置此文件的长度。
&&&&&&&&&&尝试跳过输入的 n 个字节以丢弃跳过的字节。
(byte[]&b)
&&&&&&&&&&将 b.length 个字节从指定 byte 数组写入到此文件，并从当前文件指针开始。
(byte[]&b,
&&&&&&&&&&将 len 个字节从指定 byte 数组写入到此文件，并从偏移量 off 处开始。
&&&&&&&&&&向此文件写入指定的字节。
(boolean&v)
&&&&&&&&&&按单字节值将 boolean 写入该文件。
&&&&&&&&&&按单字节值将 byte 写入该文件。
&&&&&&&&&&按字节序列将该字符串写入该文件。
&&&&&&&&&&按双字节值将 char 写入该文件，先写高字节。
&&&&&&&&&&按字符序列将一个字符串写入该文件。
(double&v)
&&&&&&&&&&使用 Double 类中的 doubleToLongBits 方法将双精度参数转换为一个 long，然后按八字节数量将该 long 值写入该文件，先定高字节。
&&&&&&&&&&使用 Float 类中的 floatToIntBits 方法将浮点参数转换为一个 int，然后按四字节数量将该 int 值写入该文件，先写高字节。
&&&&&&&&&&按四个字节将 int 写入该文件，先写高字节。
&&&&&&&&&&按八个字节将 long 写入该文件，先写高字节。
&&&&&&&&&&按两个字节将 short 写入该文件，先写高字节。
&&&&&&&&&&使用
编码以与机器无关的方式将一个字符串写入该文件。
, , , , , , , , , ,
RandomAccessFile
public RandomAccessFile(&name,
创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。将创建一个新的
对象来表示到文件的连接。
mode 参数指定用以打开文件的访问模式。允许的值及其含意如 RandomAccessFile(File,String) 构造方法所指定的那样。
如果存在安全管理器，则使用 name 作为其参数调用其 checkRead 方法，以查看是否允许对该文件进行读取访问。如果该模式允许写入，那么还使用 name 作为安全管理器的参数来调用其 checkWrite 方法，以查看是否允许对该文件进行写入访问。
参数：name - 取决于系统的文件名mode - 此访问
- 如果此模式参数与 &r&、&rw&、&rws& 或 &rwd& 的其中一个不相等
- 如果该模式为 &r&，但给定的字符串表示一个现有的常规文件，或者该模式以 &rw& 开头，但给定的字符串不表示一个现有的可写常规文件，而且无法创建具有该名称的新常规文件，或者在打开或创建该文件时发生一些其他错误
- 如果存在安全管理器，并且其 checkRead 方法拒绝对该文件的读取访问，或者该模式为 &rw&，并且该安全管理器的 checkWrite 方法拒绝对该文件的写入访问另请参见：,
RandomAccessFile
public RandomAccessFile(&file,
创建从中读取和向其中写入（可选）的随机访问文件流，该文件由
参数指定。将创建一个新的
对象来表示此文件的连接。
打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。
打开以便读取和写入，对于 &rw&，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。
打开以便读取和写入，对于 &rw&，还要求对文件内容的每个更新都同步写入到底层存储设备。
&rws& 和 &rwd& 模式的工作方式极其类似
方法，分别传递 true 和 false 参数，除非它们始终应用于每个 I/O 操作，并因此通常更为高效。如果该文件位于本地存储设备上，那么当返回此类的一个方法的调用时，可以保证由该调用对此文件所做的所有更改均被写入该设备。这对确保在系统崩溃时不会丢失重要信息特别有用。如果该文件不在本地设备上，则无法提供这样的保证。
&rwd& 模式可用于减少执行的 I/O 操作数量。使用 &rwd& 仅要求更新要写入存储的文件的内容；使用 &rws& 要求更新要写入的文件内容及其元数据，这通常要求至少一个以上的低级别 I/O 操作。
如果存在安全管理器，则使用 file 参数的路径名作为其参数调用它的 checkRead 方法，以查看是否允许对该文件进行读取访问。如果该模式允许写入，那么还使用该路径参数调用该安全管理器的 checkWrite 方法，以查看是否允许对该文件进行写入访问。
参数：file - 该文件对象mode - 访问模式，如所述
- 如果此模式参数与 &r&、&rw&、&rws& 或 &rwd& 的其中一个不相等
- 如果该模式为 &r&，但给定的文件对象不表示一个现有的常规文件，或者该模式以 &rw& 开头，但给定的文件对象不表示一个现有的可写常规文件，而且无法创建具有该名称的新常规文件，或者在打开或创建该文件时发生一些其他错误
- 如果存在安全管理器，并且其 checkRead 方法拒绝对该文件的读取访问，或者该模式为 &rw&，并且该安全管理器的 checkWrite 方法拒绝对该文件的写入访问另请参见：,
public final
返回与此流关联的不透明文件描述符对象。
返回：与此流关联的不透明文件描述符对象。
- 如果发生 I/O 错误。另请参见：
getChannel
public final
getChannel()
返回与此文件关联的唯一
返回通道的 java.nio.channels.FileChannel#position()position 将始终等于
方法返回的此对象的文件指针偏移量。显式或者通过读取或写入字节来更改此对象的文件指针偏移量将更改通道的位置，反之亦然。通过此对象更改此文件的长度将更改通过文件通道看到的长度，反之亦然。
返回：与此文件关联的文件通道从以下版本开始：
public int read()
从此文件中读取一个数据字节。以整数形式返回此字节，范围在 0 到 255 (0x00-0x0ff)。如果尚无输入可用，将阻塞此方法。
尽管 RandomAccessFile 不是 InputStream 的子类，但此方法的行为与 InputStream 的
方法完全一样。
返回：下一个数据字节，如果已到达文件的末尾，则返回 -1。
- 如果发生 I/O 错误。如果已到达文件的末尾，则不抛出此异常。
public int read(byte[]&b,
将最多 len 个数据字节从此文件读入 byte 数组。在至少一个输入字节可用前，此方法一直阻塞。
尽管 RandomAccessFile 不是 InputStream 的子类，但此方法的行为与 InputStream 的
方法完全一样。
参数：b - 读入数据的缓冲区。off - 写入数据的数组 b 中的初始偏移量。len - 读取的最多字节数。
返回：读入缓冲区的总字节数，如果由于已到达文件的末尾而不再有数据，则返回 -1。
- 如果由于文件结束之外的某种原因不能读取第一个字节，或者随机访问文件已关闭，或者发生其他 I/O 错误。
- 如果 b 为 null。
- 如果 off为负，len 为负，或者 len 大于 b.length - off
public int read(byte[]&b)
将最多 b.length 个数据字节从此文件读入 byte 数组。在至少一个输入字节可用前，此方法一直阻塞。
尽管 RandomAccessFile 不是 InputStream 的子类，但此方法的行为与 InputStream 的
方法完全一样。
参数：b - 将数据读入的缓冲区。
返回：读入缓冲区的总字节数，如果由于已到达此文件的末尾而不再有数据，则返回 -1。
- 如果由于文件结束之外的某种原因不能读取第一个字节，或者随机访问文件已关闭，或者发生其他 I/O 错误。
- 如果 b 为 null。
public final void readFully(byte[]&b)
将 b.length 个字节从此文件读入 byte 数组，并从当前文件指针开始。在读取到请求数量的字节之前，此方法将从该文件重复读取。在读取了请求数量的字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
参数：b - 将数据读入的缓冲区。
- 如果在读取所有字节之前此文件已到达末尾。
- 如果发生 I/O 错误。
public final void readFully(byte[]&b,
将正好 len 个字节从此文件读入 byte 数组，并从当前文件指针开始。在读取到请求数量的字节之前，此方法将从该文件重复读取。在读取了请求数量的字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
参数：b - 读入数据的缓冲区。off - 数据的初始偏移量。len - 要读取的字节数。
- 如果在读取所有字节之前此文件已到达末尾。
- 如果发生 I/O 错误。
public int skipBytes(int&n)
尝试跳过输入的 n 个字节以丢弃跳过的字节。
此方法可能跳过一些较少数量的字节（可能包括零）。这可能由任意数量的条件引起；在跳过 n 个字节之前已到达文件的末尾只是其中的一种可能。此方法从不抛出 EOFException。返回跳过的实际字节数。如果 n 为负数，则不跳过任何字节。
指定者：接口
参数：n - 要跳过的字节数。
返回：跳过的实际字节数。
- 如果发生 I/O 错误。
public void write(int&b)
向此文件写入指定的字节。从当前文件指针开始写入。
指定者：接口
参数：b - 要写入的 byte。
- 如果发生 I/O 错误。
public void write(byte[]&b)
将 b.length 个字节从指定 byte 数组写入到此文件，并从当前文件指针开始。
指定者：接口
参数：b - 数据。
- 如果发生 I/O 错误。
public void write(byte[]&b,
将 len 个字节从指定 byte 数组写入到此文件，并从偏移量 off 处开始。
指定者：接口
参数：b - 数据。off - 数据的初始偏移量。len - 要写入的字节数。
- 如果发生 I/O 错误。
getFilePointer
public long getFilePointer()
返回此文件中的当前偏移量。
返回：到此文件开头的偏移量（以字节为单位），在该位置发生下一个读取或写入操作。
- 如果发生 I/O 错误。
public void seek(long&pos)
设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。偏移量的设置可能会超出文件末尾。偏移量的设置超出文件末尾不会改变文件的长度。只有在偏移量的设置超出文件末尾的情况下对文件进行写入才会更改其长度。
参数：pos - 从文件开头以字节为单位测量的偏移量位置，在该位置设置文件指针。
- 如果 pos 小于 0 或者发生 I/O 错误。
public long length()
返回此文件的长度。
返回：按字节测量的此文件的长度。
- 如果发生 I/O 错误。
public void setLength(long&newLength)
设置此文件的长度。
如果 length 方法返回的文件的现有长度大于 newLength 参数，则该文件将被截短。在此情况下，如果 getFilePointer 方法返回的文件偏移量大于 newLength，那么在返回此方法后，该偏移量将等于 newLength。
如果 length 方法返回的文件的现有长度小于 newLength 参数，则该文件将被扩展。在此情况下，未定义文件扩展部分的内容。
参数：newLength - 文件的所需长度
- 如果发生 I/O 错误从以下版本开始：
public void close()
关闭此随机访问文件流并释放与该流关联的所有系统资源。关闭的随机访问文件不能执行输入或输出操作，而且不能重新打开。
如果此文件具有一个关联的通道，那么该通道也会被关闭。
指定者：接口
- 如果发生 I/O 错误。
readBoolean
public final boolean readBoolean()
从此文件读取一个 boolean。此方法从该文件的当前文件指针开始读取单个字节。值 0 表示 false。其他任何值表示 true。在读取了该字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：读取的 boolean 值。
- 如果此文件已到达末尾。
- 如果发生 I/O 错误。
public final byte readByte()
从此文件读取一个有符号的八位值。此方法从该文件的当前文件指针开始读取一个字节。如果读取的字节为 b，其中 0&&=&b&&=&255，则结果将是：
在读取了该字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：以有符号的八位 byte 形式返回此文件的下一个字节。
- 如果此文件已到达末尾。
- 如果发生 I/O 错误。
readUnsignedByte
public final int readUnsignedByte()
从此文件读取一个无符号的八位数。此方法从此文件的当前文件指针开始读取一个字节，并返回该字节。
在读取了该字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：此文件的下一个字节，解释为一个无符号的八位数。
- 如果此文件已到达末尾。
- 如果发生 I/O 错误。
public final short readShort()
从此文件读取一个有符号的 16 位数。此方法从此文件的当前文件指针开始读取两个字节。如果按顺序读取的两个字节为 b1 和 b2，其中两个值都在 0 和 255之间（包含），则此结果等于：
(short)((b1 && 8) | b2)
在读取了这两个字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：此文件的下两个字节，解释为一个有符号的 16 位数。
- 如果在读取两个字节之前此文件已到达末尾。
- 如果发生 I/O 错误。
readUnsignedShort
public final int readUnsignedShort()
从此文件读取一个无符号的 16 位数。此方法从该文件的当前文件指针开始读取两个字节。如果按顺序读取的字节为 b1 和 b2，其中 0&&=&b1, b2&&=&255，则结果将等于：
(b1 && 8) | b2
在读取了这两个字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：此文件的下两个字节，解释为一个无符号的 16 位整数。
- 如果在读取两个字节之前此文件已到达末尾。
- 如果发生 I/O 错误。
public final char readChar()
从此文件读取一个字符。此方法从该文件的当前文件指针开始读取两个字节。如果按顺序读取的字节为 b1 和 b2，其中 0&#xA0;&=&#xA0;b1, b2&#xA0;&=&#xA0;255，则结果将等于：
(char)((b1 && 8) | b2)
在读取了这两个字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：此文件的下两个字节，解释为 char。
- 如果在读取两个字节之前此文件已到达末尾。
- 如果发生 I/O 错误。
public final int readInt()
从此文件读取一个有符号的 32 位整数。此方法从该文件的当前文件指针开始读取 4 个字节。如果按顺序读取的字节为 b1、b2、b3 和 b4，其中 0&&=&b1, b2, b3, b4&&=&255，则结果将等于：
(b1 && 24) | (b2 && 16) + (b3 && 8) + b4
在读取了这四个字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：此文件的下四个字节，解释为一个 int。
- 如果在读取四个字节之前此文件已到达末尾。
- 如果发生 I/O 错误。
public final long readLong()
从此文件读取一个有符号的 64 位整数。此方法从该文件的当前文件指针开始读取八个字节。如果按顺序读取的字节为 b1、b2、b3、b4、b5、b6、b7 和 b8，其中：
0 &= b1, b2, b3, b4, b5, b6, b7, b8 &=255,
则结果将等于：
((long)b1 && 56) + ((long)b2 && 48)
+ ((long)b3 && 40) + ((long)b4 && 32)
+ ((long)b5 && 24) + ((long)b6 && 16)
+ ((long)b7 && 8) + b8
在读取了这八个字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：此文件的下八个字节，解释为一个 long。
- 如果在读取八个字节之前此文件已到达末尾。
- 如果发生 I/O 错误。
public final float readFloat()
从此文件读取一个 float。此方法从当前文件指针开始读取一个 int 值，类似于使用 readInt 方法，然后使用 Float 类中的 intBitsToFloat 方法将该 int 转换为一个 float。
在读取了这四个字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：此文件的下四个字节，解释为一个 float。
- 如果在读取四个字节之前此文件已到达末尾。
- 如果发生 I/O 错误。另请参见：,
readDouble
public final double readDouble()
从此文件读取一个 double。此方法从当前文件指针开始读取一个 long 值，类似于使用 readLong 方法，然后使用 Double 类中的 longBitsToDouble 方法将该 long 转换为一个 double。
在读取了这八个字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：此文件的下八个字节，解释为一个 double。
- 如果在读取八个字节之前此文件已到达末尾。
- 如果发生 I/O 错误。另请参见：,
public final
readLine()
从此文件读取文本的下一行。此方法可以从该文件的当前文件指针处成功地读取字节，直到到达行结束符或文件的末尾。每个字节都转换为一个字符，方法是采用该字符的低八位字节值，并将该字符的高八位设置为零。因此，此方法不支持完整的 Unicode 字符集。
文本行由回车符 ('\r') 和一个换行符 ('\n') 结束，回车符后面紧跟一个换行符，或者是文件的末尾。不使用行结束符，并且在返回的字符串中不包括结束符。
在读取了一个换行符、读取了一个回车符和它后面的字节（查看是否为一个新行），到达文件的末尾或者抛出异常之前，此方法一直阻塞。
指定者：接口
返回：此文件文本的下一行，如果连一个字节也没有读取就已到达文件的末尾，则返回 null。
- 如果发生 I/O 错误。
public final
从此文件读取一个字符串。该字符串已使用 格式进行编码。
从当前文件指针开始读取前两个字节，类似于使用 readUnsignedShort。此值给出已编码字符串中随后的字节数，而不是结果字符串的长度。随后的字节然后解释为 UTF-8 修改版格式的字节编码字符，并转换为字符。
在读取了所有字节、检测到流的末尾或者抛出异常前，此方法一直阻塞。
指定者：接口
返回：一个 Unicode 字符串。
- 如果在读取所有字节之前此文件已到达末尾。
- 如果发生 I/O 错误。
- 如果这些字节不表示 Unicode 字符串的有效 UTF-8 修改版编码。另请参见：
writeBoolean
public final void writeBoolean(boolean&v)
按单字节值将 boolean 写入该文件。值 true 写出为值 (byte)1；值 false 写出为值 (byte)0。写入从文件指针的当前位置开始。
指定者：接口
参数：v - 要写入的 boolean 值。
- 如果发生 I/O 错误。
public final void writeByte(int&v)
按单字节值将 byte 写入该文件。写入从文件指针的当前位置开始。
指定者：接口
参数：v - 要写入的 byte 值。
- 如果发生 I/O 错误。
writeShort
public final void writeShort(int&v)
按两个字节将 short 写入该文件，先写高字节。写入从文件指针的当前位置开始。
指定者：接口
参数：v - 要写入的 short。
- 如果发生 I/O 错误。
public final void writeChar(int&v)
按双字节值将 char 写入该文件，先写高字节。写入从文件指针的当前位置开始。
指定者：接口
参数：v - 要写入的 char 值。
- 如果发生 I/O 错误。
public final void writeInt(int&v)
按四个字节将 int 写入该文件，先写高字节。写入从文件指针的当前位置开始。
指定者：接口
参数：v - 要写入的 int。
- 如果发生 I/O 错误。
public final void writeLong(long&v)
按八个字节将 long 写入该文件，先写高字节。写入从文件指针的当前位置开始。
指定者：接口
参数：v - 要写入的 long。
- 如果发生 I/O 错误。
writeFloat
public final void writeFloat(float&v)
使用 Float 类中的 floatToIntBits 方法将浮点参数转换为一个 int，然后按四字节数量将该 int 值写入该文件，先写高字节。写入从文件指针的当前位置开始。
指定者：接口
参数：v - 要写入的 float 值。
- 如果发生 I/O 错误。另请参见：
writeDouble
public final void writeDouble(double&v)
使用 Double 类中的 doubleToLongBits 方法将双精度参数转换为一个 long，然后按八字节数量将该 long 值写入该文件，先定高字节。写入从文件指针的当前位置开始。
指定者：接口
参数：v - 要写入的 double 值。
- 如果发生 I/O 错误。另请参见：
writeBytes
public final void writeBytes(&s)
按字节序列将该字符串写入该文件。该字符串中的每个字符均按顺序写出，并丢弃其高八位。写入从文件指针的当前位置开始。
指定者：接口
参数：s - 要写入的字节的字符串。
- 如果发生 I/O 错误。
writeChars
public final void writeChars(&s)
按字符序列将一个字符串写入该文件。每个字符均写入数据输出流，类似于使用 writeChar 方法。写入从文件指针的当前位置开始。
指定者：接口
参数：s - 要写入的 boolean 值。
- 如果发生 I/O 错误。另请参见：
public final void writeUTF(&str)
编码以与机器无关的方式将一个字符串写入该文件。
首先，把两个字节从文件的当前文件指针写入到此文件，类似于使用 writeShort 方法并给定要跟随的字节数。此值是实际写出的字节数，而不是该字符串的长度。在该长度之后，按顺序输出该字符串的每个字符，并对每个字符使用 UTF-8 修改版编码。
指定者：接口
参数：str - 要写入的字符串。
- 如果发生 I/O 错误。
JavaTM&2&PlatformStandard&Ed. 6
版权所有 2008 Sun Microsystems, Inc. 保留所有权利。请遵守。Java_io体系之RandomAccessFile简介、走进源码及示例——20-android100学习网
Java_io体系之RandomAccessFile简介、走进源码及示例——20
Java_io体系之RandomAccessFile简介、走进源码及示例——20 RandomAccessFile1、
类功能简介：
文件随机访问流、关...
Java_io体系之RandomAccessFile简介、走进源码及示例——20
RandomAccessFile
类功能简介：
文件随机访问流、关心几个特点：
1、他实现的接口不再是InputStream、OutputStream中的任何一个、而是实现的DataInput、DataOutput。这也注定了他可以对java基础类型进行操作、而且是即可读取、也可以写入、关于这部分的方法大多数都是从DataInputStream、DataOutputStream那里荡来的。
2、如其名、随机流、这里的随机并不是不可控制、不可预测的去访问文件、而是可以通过指针的形式定位到具体的位置——“文件指针”、具体使用“文件指针”的方法：调用此流的seek(long n)方法来设置位置、使用此方法要注意的是如果传入的n大于文件长度、此方法不会改变文件长度、只是当写入下一个字节时会改变文件大小、即下一个写入的字节是添加在n后的。如果n小于文件长度、则会从n位置开始覆盖后面的file内容、
3、此流既可以读取文件、也可以写入文件、也可具有只读功能、但是没有只写功能、具体是哪种类型是在构造方法中指定的——S具体的区别上面有说明。。
这里把实例放在了前面、因为源码和方法所占篇幅太长、有兴趣的可继续往下看。
实例演示：
package com.chy.io.original.
import java.io.F
import java.io.IOE
import java.io.RandomAccessF
public class RandomAccessFileTests {
private static final File file = new File("D:\\rsf.txt");
* 向文件中写入内容
public static void testRandomAccessFileWriter() throws IOException{
//要先将已有文件删除、避免干扰。
if(file.exists()){
file.delete();
RandomAccessFile rsfWriter = new RandomAccessFile(file, "rw");
//不会改变文件大小、但是他会将下一个字符的写入位置标识为10000、也就是说此后只要写入内容、就是从10001开始存、
rsfWriter.seek(10000);
printFileLength(rsfWriter);
//result: 0
//会改变文件大小、只是把文件的size改变、并没有改变下一个要写入的内容的位置、这里注释掉是为了验证上面的seek方法的说明内容
//rsfWriter.setLength(10000);
printFileLength(rsfWriter);
//result: 0
//每个汉子占3个字节、写入字符串的时候会有一个记录写入字符串长度的两个字节
rsfWriter.writeUTF("陈华应");
printFileLength(rsfWriter);
//result: 10011
//每个字符占两个字节
rsfWriter.writeChar('a');
rsfWriter.writeChars("abcde");
printFileLength(rsfWriter);
//result: 10023
//再从“文件指针”为5000的地方插一个长度为100、内容全是'a'的字符数组
//这里file长依然是10023、因为他是从“文件指针”为5000的地方覆盖后面的200个字节、下标并没有超过文件长度
rsfWriter.seek(5000);
char[] cbuf = new char[100];
for(int i=0; i
RandomAccessFile
A：构造方法
RandomAccessFile(File file, String mode)
创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。
RandomAccessFile(String name, String mode)
从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。
补充一：mode的取值有下面四种情况
以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
打开以便读取和写入。
打开以便读取和写入。相对于 "rw"，"rws" 还要求对“文件的内容”或“元数据”的每个更新都同步写入到基础存储设备。
打开以便读取和写入，相对于 "rw"，"rwd" 还要求对“文件的内容”的每个更新都同步写入到基础存储设备。
补充二：关于文件的“元数据”
The definition of metadata is "data about other data." With a file system, the data is contained in its files and directories, and the metadata tracks information about each of these objects: Is it a regular file, a directory,
or a link? What is its size, creation date, last modified date, file owner, group owner, and access permissions?
补充三："rw"
"rwd"之间的区别
当操作的文件是存储在本地的基础存储设备上时(如硬盘, NandFlash等)，"rws" 或 "rwd", "rw" 才有区别。
当模式是 "rws" 并且 操作的是基础存储设备上的文件；那么，每次“更改文件内容[如write()写入数据]” 或 “修改文件元数据(如文件的mtime)”时，都会将这些改变同步到基础存储设备上。
当模式是 "rwd" 并且 操作的是基础存储设备上的文件；那么，每次“更改文件内容[如write()写入数据]”时，都会将这些改变同步到基础存储设备上。
当模式是 "rw" 并且 操作的是基础存储设备上的文件；那么，关闭文件时，会将“文件内容的修改”同步到基础存储设备上。至于，“更改文件内容”时，是否会立即同步，取决于系统底层实现。
一般使用前两个就ok。
B：一般方法
void close()
关闭此随机访问文件流并释放与该流关联的所有系统资源。
FileChannel getChannel()
返回与此文件关联的唯一 FileChannel 对象。
FileDescriptor getFD()
返回与此流关联的不透明文件描述符对象。
long getFilePointer()
返回此文件中的当前偏移量。
long length()
返回此文件的长度。
int read()
从此文件中读取一个数据字节。
int read(byte[] b)
将最多 b.length 个数据字节从此文件读入 byte 数组。
int read(byte[] b, int off, int len)
将最多 len 个数据字节从此文件读入 byte 数组。
boolean readBoolean()
从此文件读取一个 boolean。
byte readByte()
从此文件读取一个有符号的八位值。
char readChar()
从此文件读取一个字符。
double readDouble()
从此文件读取一个 double。
float readFloat()
从此文件读取一个 float。
void readFully(byte[] b)
将 b.length 个字节从此文件读入 byte 数组，并从当前文件指针开始。
void readFully(byte[] b, int off, int len)
将正好 len 个字节从此文件读入 byte 数组，并从当前文件指针开始。
int readInt()
从此文件读取一个有符号的 32 位整数。
String readLine()
从此文件读取文本的下一行。
long readLong()
从此文件读取一个有符号的 64 位整数。
short readShort()
从此文件读取一个有符号的 16 位数。
int readUnsignedByte()
从此文件读取一个无符号的八位数。
int readUnsignedShort()
从此文件读取一个无符号的 16 位数。
String readUTF()
从此文件读取一个字符串。
void seek(long pos)
设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
void setLength(long newLength)
设置此文件的长度。
int skipBytes(int n)
尝试跳过输入的 n 个字节以丢弃跳过的字节。
void write(byte[] b)
将 b.length 个字节从指定 byte 数组写入到此文件，并从当前文件指针开始。
void write(byte[] b, int off, int len)
将 len 个字节从指定 byte 数组写入到此文件，并从偏移量 off 处开始。
void write(int b)
向此文件写入指定的字节。
void writeBoolean(boolean v)
按单字节值将 boolean 写入该文件。
void writeByte(int v)
按单字节值将 byte 写入该文件。
void writeBytes(String s)
按字节序列将该字符串写入该文件。
void writeChar(int v)
按双字节值将 char 写入该文件，先写高字节。
void writeChars(String s)
按字符序列将一个字符串写入该文件。
void writeDouble(double v)
使用 Double 类中的 doubleToLongBits 方法将双精度参数转换为一个 long，然后按八字节数量将该 long 值写入该文件，先定高字节。
void writeFloat(float v)
使用 Float 类中的 floatToIntBits 方法将浮点参数转换为一个 int，然后按四字节数量将该 int 值写入该文件，先写高字节。
void writeInt(int v)
按四个字节将 int 写入该文件，先写高字节。
void writeLong(long v)
按八个字节将 long 写入该文件，先写高字节。
void writeShort(int v)
按两个字节将 short 写入该文件，先写高字节。
void writeUTF(String str)
使用 modified UTF-8 编码以与机器无关的方式将一个字符串写入该文件。
package com.chy.io.original.
import java.io.C
import java.io.EOFE
import java.io.F
import java.io.FileD
import java.io.FileNotFoundE
import java.io.IOE
import java.io.UTFDataFormatE
import java.nio.channels.FileC
import sun.nio.ch.FileChannelI
* 随机访问文件流、既可以对文件进行读取、也可以对文件进行写入、还可以写入java基础类型、不再是InputStream或者OutputStream的子类、
* 而是实现了DataOutput、DataInput、通过这两个接口也可以看出、此类具有将java基础类型写入文件或者读取到程序中的功能、关于写入/读取文件基础类型
* 的操作大多数都是剽窃DataInputStream/DataOutputStream的。
public class RandomAccessFile implements DataOutput, DataInput, Closeable {
java.io.RandomAccessFile
private FileD
private FileChannel channel =
//标识此文件是否既可以读又可以写
//标识不同mode对应的值
private static final int O_RDONLY = 1;
private static final int O_RDWR =
private static final int O_SYNC =
private static final int O_DSYNC =
* 使用指定的文件、模式构造RandomAccessFile、初始化参数、打开到文件的连接
public RandomAccessFile(String name, String mode)
throws FileNotFoundException
this(name != null ? new File(name) : null, mode);
* 使用指定的文件、模式构造RandomAccessFile、初始化参数、打开到文件的连接
public RandomAccessFile(File file, String mode)
throws FileNotFoundException
String name = (file != null ? file.getPath() : null);
int imode = -1;
if (mode.equals("r"))
imode = O_RDONLY;
else if (mode.startsWith("rw")) {
imode = O_RDWR;
if (mode.length() & 2) {
if (mode.equals("rws"))
imode |= O_SYNC;
else if (mode.equals("rwd"))
imode |= O_DSYNC;
imode = -1;
seek(newpos);
/* return the actual number of bytes skipped */
return (int) (newpos - pos);
// 'Write' primitives
* 在当前“文件指针”标示的地方写入一个字节
public native void write(int b) throws IOE
* 将b的一部分写入到文件中
private native void writeBytes(byte b[], int off, int len) throws IOE
* 将b写入到文件中
public void write(byte b[]) throws IOException {
writeBytes(b, 0, b.length);
* 将b的一部分写入到文件中
public void write(byte b[], int off, int len) throws IOException {
writeBytes(b, off, len);
// 'Random access' stuff
* 返回当前文件的偏移量、即“文件描述符”的位置
public native long getFilePointer() throws IOE
* 设置“文件指针”的偏移量、从文件的开头开始计数、如果pos大于文件的长度、也不会改变文件的大小、
* 文件的大小只有在当“文件指针”指向文件最后的时候、再向文件中写入字节才会扩展。
public native void seek(long pos) throws IOE
* 返回文件的字节数
public native long length() throws IOE
* 设置文件长度：
if(newLength & originalLength)
扩展文件长度、新增加的长度使用默认值填充;
截取源文件的前originalLength字节、如果源文件的偏移量大于newLength、则将源文件的偏移量设为newL
public native void setLength(long newLength) throws IOE
* 关闭此流、释放与此流有关的所有资源
public void close() throws IOException {
if (channel != null)
channel.close();
一些方法是从DataInputStream/DataOutputStream中剽窃来的。。。
* 读取一个boolean型数据
public final boolean readBoolean() throws IOException {
int ch = this.read();
if (ch && 8) & 0xFF);
write((v &&& 0) & 0xFF);
//written += 2;
* 将一个char写入文件
public final void writeChar(int v) throws IOException {
write((v &&& 8) & 0xFF);
write((v &&& 0) & 0xFF);
//written += 2;
* 将一个int写入文件
public final void writeInt(int v) throws IOException {
write((v &&& 24) & 0xFF);
write((v &&& 16) & 0xFF);
write((v &&&
8) & 0xFF);
write((v &&&
0) & 0xFF);
//written += 4;
* 将一个long写入文件
public final void writeLong(long v) throws IOException {
write((int)(v &&& 56) & 0xFF);
write((int)(v &&& 48) & 0xFF);
write((int)(v &&& 40) & 0xFF);
write((int)(v &&& 32) & 0xFF);
write((int)(v &&& 24) & 0xFF);
write((int)(v &&& 16) & 0xFF);
write((int)(v &&&
8) & 0xFF);
write((int)(v &&&
0) & 0xFF);
//written += 8;
* 将一个long写入文件
public final void writeFloat(float v) throws IOException {
writeInt(Float.floatToIntBits(v));
* 将一个double写入文件。
public final void writeDouble(double v) throws IOException {
writeLong(Double.doubleToLongBits(v));
* 将一个字符串转换成一串有序字节写入
public final void writeBytes(String s) throws IOException {
int len = s.length();
byte[] b = new byte[len];
s.getBytes(0, len, b, 0);
writeBytes(b, 0, len);
* 将一个字符串以一串有序字符写入文件中
public final void writeChars(String s) throws IOException {
int clen = s.length();
int blen = 2*
byte[] b = new byte[blen];
char[] c = new char[clen];
s.getChars(0, clen, c, 0);
for (int i = 0, j = 0; i && 8);
b[j++] = (byte)(c[i] &&& 0);
writeBytes(b, 0, blen);
* 调用DataOutputStream的 writeUTF(String str, DataOutput out) 将一个字符串写入文件。
public final void writeUTF(String str) throws IOException {
DataOutputStream.writeUTF(str, this);
private static native void initIDs();
private native void close0() throws IOE
initIDs();
更多IO内容：java_io
体系之目录}