java IO笔记(RandomAccessFile)

本篇讲述的内容是java io中的RandomAccessFile。

RandomAccessFile是java io体系中提供给我们的一种文件访问类，它自己同时包含了读写功能，当然它最大的特点是可以自由访问文件中的位置，无需从头开始访问，下面先贴上RandomAccessFile的源码，通过源码对其进行学习。

package java.io;import java.nio.channels.FileChannel;import sun.nio.ch.FileChannelImpl;public class RandomAccessFile implements DataOutput, DataInput, Closeable {    //声明了一个文件描述符的句柄。    private FileDescriptor fd;    //声明了一个文件通道的句柄，并将其指向null。    private FileChannel channel = null;    //定义了一个boolean型变量rw，用于表示文件的读写权限。    private boolean rw;    //定义了一个String类型的变量path，用于接收    private final String path;    //定义了一个Object对象，为后面close方法中的同步操作提供锁对象。    private Object closeLock = new Object();    //定义了一个boolean型变量closed，用于表示当前流是否关闭，用volatile关键字修饰，保证了其改变的可见性。    private volatile boolean closed = false;        //定义了4个常量，分别表示了RandomAccessFile的4种读写模式。    private static final int O_RDONLY = 1;//只读模式，不具备写权限，如果文件不存在不会创建文件。    private static final int O_RDWR =   2;//读写模式，具备读写权限，如果文件不存在会创建文件，该模式下数据改变时不会立马写入底层存储设备。    private static final int O_SYNC =   4;//同步的读写模式，具备读写模式的所有特性，当文件内容或元数据改变时，会立马同步写入到底层存储设备中。    private static final int O_DSYNC =  8;//同步的读写模式，具备读写模式的所有特性，当文件内容改变时，会立马同步写入到底层存储设备中。    /**     * 带两个参数的构造方法，第一个参数为String类型，表示需要进行操作的文件路径名，第二个参数为String类型，表示以什么模式打开文件（四种模式，r，rw，rws，     * rwd）。内部实质是继续调用后面的构造函数RandomAccessFile(File file, String mode)。     */       public RandomAccessFile(String name, String mode)        throws FileNotFoundException    {        this(name != null ? new File(name) : null, mode);    }    /**     * 带两个参数的构造方法，第一个参数为File类型，表示要进行操作的文件对象，第二个参数为String类型，表示打开文件的模式。     */    public RandomAccessFile(File file, String mode)        throws FileNotFoundException    {// 定义了一个String类型变量name用于接收操作文件的路径名，如果文件为null，则name赋值为null。        String name = (file != null ? file.getPath() : null);// 定义了一个int型变量imode，表示打开文件的模式状态，初始化默认为-1。        int imode = -1;// 对传入的参数mode进行匹配，给imode，rw赋值，表示读写权限。        if (mode.equals("r"))    //"r",只读模式。            imode = O_RDONLY;        else if (mode.startsWith("rw")) {    //"rw"，读写模式            imode = O_RDWR;            rw = true;            if (mode.length() > 2) {//同步的读写模式。                if (mode.equals("rws"))                    imode |= O_SYNC;                else if (mode.equals("rwd"))                    imode |= O_DSYNC;                else                    imode = -1;             }        }//如果imode<0(其实就是等于-1)，那么抛出相应的异常，提示传入的读写模式是非法的，并告知是要填四种合法模式中的一种。        if (imode < 0)            throw new IllegalArgumentException("Illegal mode \"" + mode                                               + "\" must be one of "                                               + "\"r\", \"rw\", \"rws\","                                               + " or \"rwd\"");//获得java的安全管理器，根据rw的状态监测文件的读写权限。        SecurityManager security = System.getSecurityManager();        if (security != null) {            security.checkRead(name);            if (rw) {                security.checkWrite(name);            }        } //如果name为null，抛出相应的异常，NullPointerException。        if (name == null) {            throw new NullPointerException();        }//如果file.isInvalid的值为true，则表示file对象不合法，抛出相应的异常，FileNotFoundException。        if (file.isInvalid()) {            throw new FileNotFoundException("Invalid file path");        }//将声明的句柄指向一个新建的文件描述符对象，并将本类对象依附在该文件描述符上。为path赋值，然后调用open方法根据指定路径和模式打开文件。        fd = new FileDescriptor();        fd.attach(this);        path = name;        open(name, imode);    }    /**     * 该方法用于获取当前文件的文件描述符。     */    public final FileDescriptor getFD() throws IOException {        if (fd != null) {            return fd;        }        throw new IOException();    }    /**     * 该方法用于获取当前文件的文件管道。     */    public final FileChannel getChannel() {        synchronized (this) {            if (channel == null) {                channel = FileChannelImpl.open(fd, path, true, rw, this);            }            return channel;        }    }    /**     * 一个native方法，根据传入的文件路径及读写模式来打开文件。     */    private native void open(String name, int mode)        throws FileNotFoundException;    //此处开始是RandomAccessFile的读操作    /**     * 定义了一个read方法，每次从文件中读取一个字节的内容，并以int型返回读取的数据。内部实质是调用native方法read0()。     */    public int read() throws IOException {        return read0();    }    /**     * 定义了一个native方法read0，用于每次从文件中读取一个字节的内容，并以int型将读取的数据返回。     */    private native int read0() throws IOException;    /**     * 定义了一个native方法readBytes方法，一次可以读取多个字节，并将读取的数据放入传入的字节数组当中，最终返回实际读取到的字节个数。     */    private native int readBytes(byte b[], int off, int len) throws IOException;    /**     * 定义了一个带三个参数的read方法，第一个参数为一个byte型数组，用于存放读取的字节内容，第二和第三个参数都是一个int型数值，分别表示了读取的起点以及读     * 取的长度。内部实质上是调用native方法readBytes方法来读取数据。     */    public int read(byte b[], int off, int len) throws IOException {        return readBytes(b, off, len);    }    /**     * 定义了一个带一个参数的read方法，传入的参数为一个byte型数组，用于存放读取的字节数据，内部实质上是调用native方法readBytes方法，起点为0长度为传入的     * 数组容量。     */    public int read(byte b[]) throws IOException {        return readBytes(b, 0, b.length);    }    /**     * 定义了一个readFully方法，每次读取多个字节数据，传入的参数为一个byte型数组。内部实质是调用之后的带三个参数的readFully方法，只有当数组存满或者文件     * 结尾或者抛出异常时才停止。     */    public final void readFully(byte b[]) throws IOException {        readFully(b, 0, b.length);    }    /**     * 定义了一个带三个参数的readFully方法，第一个参数为一个byte型数组，用于存放读取的字节数据，第二和第三个参数为int型数据，分别为读取的起点和读取的长度     * 。当数组存满或者文件结尾或者抛出异常时才停止。     */    public final void readFully(byte b[], int off, int len) throws IOException {        int n = 0;// 通过一个循环，调用read方法来进行文件的读取，直到读取指定的长度。        do {            int count = this.read(b, off + n, len - n);            if (count < 0)                throw new EOFException();            n += count;        } while (n < len);    }    /**     * 定义了一个skipBytes方法，该方法用于跳过指定的字节数，传入的参数为一个int型数值，为需要跳过的字节数，最后返回实际跳过的字节数。     */    public int skipBytes(int n) throws IOException {  //声明了3个long型变量，pos为当前读取的字节位置，len为文件的总长度，newpos表示跳过后指定字节后的读取读取位置。        long pos;        long len;        long newpos;//如果传入的参数小于等于零，则返回零，表示没有跳过任何字节的数据。        if (n <= 0) {            return 0;        } //通过getFilePointer方法，获取当前文件读取的索引位置。通过length方法获取文件的总长度。为newpos赋值，为当前位置加上跳过的字节数。        pos = getFilePointer();        len = length();        newpos = pos + n;//如果newpos大于文件总长度，那么newpos置位到文件尾部。        if (newpos > len) {            newpos = len;        }//调用seek方法，跳至newpos处。最终返回newpos-pos的值，表示实际跳过的字节数。        seek(newpos);        return (int) (newpos - pos);    }    //此处开始是RandomAccessFile的写操作。    /**     * 定义了一个write方法，每次写入一个字节的数据，传入的参数为一个int型值，即要写入的数据。内部实质是调用native方法write0来写入数据。     */    public void write(int b) throws IOException {        write0(b);    }    //定义了一个native方法write0，传入的参数为int型数据，每次写入一个字节的数据。    private native void write0(int b) throws IOException;    /**     * 定义了一个native方法writeBytes，每次写入多个字节的数据，有三个参数，第一个参数为一个byte型数组，里面存放了要写入的数据，第二和第三个参数都是int型     * 数据，分别表示了写入的起点以及写入的长度。     */    private native void writeBytes(byte b[], int off, int len) throws IOException;    /**     * 定义了一个write方法，每次写入多个字节的数据。传入的参数为一个byte型数组，里面存放了要写入的数据，内部实质调用了native方法writeBytes来写入数据。     */    public void write(byte b[]) throws IOException {        writeBytes(b, 0, b.length);    }    /**     * 定义了一个带3个参数的write方法，每次写入多个字节的数据。第一个参数为一个byte型数组，里面存放了要写入的字节数据，第二和第三个参数为int型数据，分别     * 表示了写入的起点以及写入的长度。内部实质是调用native方法writeBytes来写入数据。     */    public void write(byte b[], int off, int len) throws IOException {        writeBytes(b, off, len);    }    //RandomAccessFile独有的随机读取操作。    /**     * 定义了一个native方法getFilePointer，该方法用来获取当前文件读取的位置。     */    public native long getFilePointer() throws IOException;    /**     * 定义了一个seek方法，用于跳过指定字节长度的数据。传入的参数为一个long型数据，代表着要跳过的字节数。     */    public void seek(long pos) throws IOException {//对传入的参数进行安全监测，如果其小于零，则抛出相应的异常。        if (pos < 0) {            throw new IOException("Negative seek offset");        } else {    //调用native方法seek0，用来跳过指定字节数量的数据。            seek0(pos);        }    }    //定义了一个native方法seek0，用于跳过指定字节长度的数据，传入的参数为一个long型数据，其表示要跳过的字节长度。    private native void seek0(long pos) throws IOException;    /**     * 定义了一个native方法length，用于获得文件的总长度     */    public native long length() throws IOException;    /**     * 定义了一个native方法setLength，用于重新设定文件的长度。     */    public native void setLength(long newLength) throws IOException;    /**     * 定义了一个close方法，用于关闭流及其相关联的系统资源。     */    public void close() throws IOException {        synchronized (closeLock) {            if (closed) {                return;            }            closed = true;        }        if (channel != null) {            channel.close();        }        fd.closeAll(new Closeable() {            public void close() throws IOException {               close0();           }        });    }    //一些从DataInputStream/DataOuputStream中读写方法，方便对不同类型的数据进行读写。    /**     * 读取一个boolean型的数据，工作原理其实就是读取一个字节的数据，比较其是否等于0，因为0表示false，非0表示true。     */    public final boolean readBoolean() throws IOException {        int ch = this.read();        if (ch < 0)            throw new EOFException();        return (ch != 0);    }    /**     * 读取一个字节的数据，工作原理其实就是调用read方法读取一个字节的数据，然后转换成byte型数据。     */    public final byte readByte() throws IOException {        int ch = this.read();        if (ch < 0)            throw new EOFException();        return (byte)(ch);    }    /**     * 读取一个不带符号字节数，工作原理就是直接调用read方法并返回。     */    public final int readUnsignedByte() throws IOException {        int ch = this.read();        if (ch < 0)            throw new EOFException();        return ch;    }    /**     * 读取一个short型数据，工作原理其实就是调用两次read方法，读取的数据作为short型数据的高八位和低八位，然后返回该数据。     */    public final short readShort() throws IOException {        int ch1 = this.read();        int ch2 = this.read();        if ((ch1 | ch2) < 0)            throw new EOFException();        return (short)((ch1 << 8) + (ch2 << 0));    }    /**     * 读取一个不带符号的short型数据，工作原理其实就是调用两次read方法，读取的数据作为short型数据的高八位和低八位，然后返回改数据。     */    public final int readUnsignedShort() throws IOException {        int ch1 = this.read();        int ch2 = this.read();        if ((ch1 | ch2) < 0)            throw new EOFException();        return (ch1 << 8) + (ch2 << 0);    }    /**     * 读取一个字符，工作原理就是调用两次read方法，读取的数据作为char型数据的高八位和低八位，然后将其返回。     */    public final char readChar() throws IOException {        int ch1 = this.read();        int ch2 = this.read();        if ((ch1 | ch2) < 0)            throw new EOFException();        return (char)((ch1 << 8) + (ch2 << 0));    }    /**     * 读取一个int型数据，调用4次read方法，读取的数据代表着int型数据高位到地位，最终返回一个int型数据     */    public final int readInt() throws IOException {        int ch1 = this.read();        int ch2 = this.read();        int ch3 = this.read();        int ch4 = this.read();        if ((ch1 | ch2 | ch3 | ch4) < 0)            throw new EOFException();        return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));    }    /**     * 读取一个long型数据，本质是调用了两次readInt方法，读取的数据作为long型数据的高32位和低32位。     */    public final long readLong() throws IOException {        return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL);    }    /**     * 读取一个Float型数据，原理是通过readInt读取一个int型数据，然后将其转换为Float型数据并返回。     */    public final float readFloat() throws IOException {        return Float.intBitsToFloat(readInt());    }    /**     * 读取一个Double型数据，原理是通过readLong读取一个lo ng型数据，然后将其转换为Double型数据并返回。     */     public final double readDouble() throws IOException {        return Double.long BitsToDouble(readLong());    }    /**     * 一次读取一行数据，并将读取到的数据返回。     */    public final String readLine() throws IOException {//创建了一个StringBuffer对象，用于接收读取的数据。        StringBuffer input = new StringBuffer();//声明了一个int型变量c，用于接收读取的数据，声明了一个boolean型变量eol，表明是否读取到了换行符。        int c = -1;        boolean eol = false;        //通过一个循环来不断读取数据。        while (!eol) {            switch (c = read()) {            case -1://返回-1表示文件已经读取完毕。            case '\n'://返回'\n'，表示读到换行符，此时将eol置为true，跳出循环。                eol = true;                break;            case '\r'://返回'\r'，将eol置为true，因为平台换行符不同，向后读取看是否有'\n'，如果没有则返回'\r'处，然后跳出循环                eol = true;                long cur = getFilePointer();                if ((read()) != '\n') {                    seek(cur);                }                break;            default://每次操作向input中添加读取的内容。                input.append((char)c);                break;            }        }//如果没有读取到任何数据，则返回null。最终将input转化成String类型然后返回。        if ((c == -1) && (input.length() == 0)) {            return null;        }        return input.toString();    }    /**     * 定义了一个readUTF的方法，实质是直接调用DataInputStream的readUTF方法。     */    public final String readUTF() throws IOException {        return DataInputStream.readUTF(this);    }    /**     * 定义了一个写入Bollean型数据的方法。原理是根据数据是否等于0来决定true和false。     */    public final void writeBoolean(boolean v) throws IOException {        write(v ? 1 : 0);    }    /**     * 每次写入一个字节的数据。     */    public final void writeByte(int v) throws IOException {        write(v);    }    /**     * 每次写入一个short型数据。实际上是通过两次write方法，每次写入一个字节的数据，分别写入short型数据高八位和低八位。     */    public final void writeShort(int v) throws IOException {        write((v >>> 8) & 0xFF);        write((v >>> 0) & 0xFF);    }    /**     * 每次写入一个char型数据。实际上是通过两次write方法，每次写入一个字节的数据，分别写入char型数据高八位和低八位。     */    public final void writeChar(int v) throws IOException {        write((v >>> 8) & 0xFF);        write((v >>> 0) & 0xFF);    }    /**     * 每次写入一个int型数据。实际上是通过4次write方法，每次写入一个字节的数据，从最高位开始，每八位一组依次写入。     */    public final void writeInt(int v) throws IOException {        write((v >>> 24) & 0xFF);        write((v >>> 16) & 0xFF);        write((v >>>  8) & 0xFF);        write((v >>>  0) & 0xFF);    }    /**     * 每次写入一个long型数据。实际上是通过8次write方法，每次写入一个字节的数据，从最高位开始，每八位一组依次写入。     */    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);    }    /**     * 每次写入一个Float型数据。实际上是先将float型数据装换成int型数据，然后调用writeInt方法写入数据。     */    public final void writeFloat(float v) throws IOException {        writeInt(Float.floatToIntBits(v));    }    /**     * 每次写入一个Double型数据。实际上是先将double型数据转换成long型数据，然后调用writeLong方法写入数据。     */    public final void writeDouble(double v) throws IOException {        writeLong(Double.doubleToLongBits(v));    }    /**     * 每次写入一个字符串，实质上是先将字符串转换为字节数组，然后调用writeBytes方法写入。     */    @SuppressWarnings("deprecation")    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);    }    /**     * 每次写入一个字符串，实质上是先将字符串转换成字符数组，在将字符数组转化成字节数组，然后调用writeBytes方法写入。     */    public final void writeChars(String s) throws IOException {        int clen = s.length();        int blen = 2*clen;        byte[] b = new byte[blen];        char[] c = new char[clen];        s.getChars(0, clen, c, 0);        for (int i = 0, j = 0; i < clen; i++) {            b[j++] = (byte)(c[i] >>> 8);            b[j++] = (byte)(c[i] >>> 0);        }        writeBytes(b, 0, blen);    }    /**     * 每次读取一个UTF字符串，实质上是直接调用DataOutputStream的writeUTF方法。     */    public final void writeUTF(String str) throws IOException {        DataOutputStream.writeUTF(str, this);    }    private static native void initIDs();    private native void close0() throws IOException;    static {        initIDs();    }}

通过以上对源码的简单分析，我们对RandomAccessFile有了初步的认识，它自身就包含了读写功能，同时具有随机读取这一大亮点。下面用一个简单的例子来简单展示一下它的用法。

package RandomIO;import java.io.File;import java.io.FileNotFoundException;import java.io.IOException;import java.io.RandomAccessFile;public class RandomIOTest1 {public static void main(String[] args) {final File source = new File("./src/file/test.avi");final File target = new File("./src/file/testcopy.avi");int ThreadNum = (int) Math.ceil(Math.ceil((double) source.length() / 1024 / 1024 / 10));for (int i = 0; i < ThreadNum; i++) {Thread thread = new Thread(new MyRunnable(i, source, target));thread.start();}}}class MyRunnable implements Runnable {private int num;private File source;private File target;MyRunnable(int num, File source, File target) {this.num = num;this.source = source;this.target = target;}@Overridepublic void run() {try (RandomAccessFile sourceFile = new RandomAccessFile(source, "rw");RandomAccessFile targetFile = new RandomAccessFile(target, "rw");) {System.out.println("线程" + num + "启动");sourceFile.seek(num * 1024 * 1024 * 10);targetFile.seek(num * 1024 * 1024 * 10);byte[] buffer = null;if ((sourceFile.length() - sourceFile.getFilePointer()) < 1024 * 1024 * 10) {buffer = new byte[(int) (sourceFile.length() - sourceFile.getFilePointer())];} else {buffer = new byte[1024 * 1024 * 10];}sourceFile.read(buffer);targetFile.write(buffer);} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}System.out.println("线程" + num + "复制结束");}}

该例子使用了多线程同时复制一个文件，每个线程拷贝10MB的数据，运行上述代码后可以在指定路径下看到拷贝成功的文件，笔者拷贝了一个100多MB的小视频，拷贝的视频可以正常播放，效果图如下：

RandomAccessFile类的功能十分强大，但人无完人，它也有着一定的缺陷，从源码中可以看出，RandomAccessFile类在进行读写操作时，都是直接与底层介质进行数据传递的，即使是读写一个字节的数据，也必须进行一次I/O操作，这样就大大降低了其工作的效率。在前面如BufferedReader/BufferedWriter的学习中，我们了解了我们可以通过内置一个数据缓存区来提升读写效率，RandomAccessFile也同样可以这样操作，我们可以完全重构一个属于自己的带缓存的BufferedRandomAccessFile类。

package RandomIO;import java.io.File;import java.io.FileNotFoundException;import java.io.IOException;import java.io.RandomAccessFile;import java.util.Arrays;public class BufferedRandomAccessFile1 extends RandomAccessFile {private static final int Default_Buffer_Size = 1024 * 8;private static final int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;private static final long BuffMask_ = ~(((long) Default_Buffer_Size) - 1L);//表示缓存区是否有未flush的数据。private boolean hasDatas; //表示是否进行同步操作，将缓存内容flush。private boolean syncNeeded_;//当前操作文件的索引位置（包括在缓存区中）。private long cPos = 0L;//磁盘上操作文件的索引位置（存储介质中）。private long diskPos_ = 0L; private long lo_, hi_ = 0L; private long maxHi_ = (long)Default_Buffer_Size; //是否到了文件结束部分。private boolean isEOF; //内置的一个数组缓存区，默认大小是8k。private byte[] buffer;public BufferedRandomAccessFile1(File file, String mode) throws IOException {this(file, mode, Default_Buffer_Size);}public BufferedRandomAccessFile1(String name, String mode)throws IOException {this(name, mode, Default_Buffer_Size);}public BufferedRandomAccessFile1(File file, String mode, int size)throws IOException {super(file, mode);init(size);}public BufferedRandomAccessFile1(String name, String mode, int size)throws FileNotFoundException {super(name, mode);init(size);}//对内置缓存区进行初始化private void init(int size) {if (size < Default_Buffer_Size) {size = Default_Buffer_Size;} else if (size > MAX_BUFFER_SIZE) {size = MAX_BUFFER_SIZE;}buffer = new byte[size];}//将缓存区中的数据同步写出到存储介质中。public void sync() throws IOException {if (syncNeeded_) {//将内置缓存区中的数据写入flush();//将文件通道内未写入磁盘的数据强制写入到磁盘中，传入的参数表示是否将文件元信息写入到磁盘之上。getChannel().force(true);syncNeeded_ = false;}}// close前将缓存区刷新一次防止缓存区中有未写入的数据，然后将缓存区置为null，调用父类的close方法释放资源。public void close() throws IOException {this.flush();this.buffer = null;super.close();}//将缓存区中内容写入存储介质中public void flush() throws IOException {this.flushBuffer();}//将缓存中内容写入存储介质之中private void flushBuffer() throws IOException {if (hasDatas) {if (diskPos_ != lo_)super.seek(lo_);int len = (int) (cPos - lo_);super.write(buffer, 0, len);diskPos_ = cPos;hasDatas = false;}}//向缓存区中填充数据。返回实际填充了多少字节的数据。private int fillBuffer() throws IOException {int nextChar = 0;int nChars = buffer.length;//通过一个循环，向缓存区中填充数据，直至将缓存区填满或者文件读到末尾。while (nChars > 0) {int n = super.read(buffer, nextChar, nChars);if (n < 0)break;nextChar += n;nChars -= n;}if ((nextChar < 0) && (isEOF = (nextChar < buffer.length))) {//将为缓存区中未填充到的部分全用-1初始化。Arrays.fill(buffer, nextChar, buffer.length, (byte) 0xff);}diskPos_ += nextChar;return nextChar;}//跳过指定的字节数public void seek(long pos) throws IOException {if (pos >= hi_ || pos < lo_) {flushBuffer();lo_ = pos & BuffMask_; maxHi_ = lo_ + (long) buffer.length;if (diskPos_ != lo_) {super.seek(lo_);diskPos_ = lo_;}int n = fillBuffer();hi_ = lo_ + (long) n;} else {if (pos < cPos) {flushBuffer();}}cPos = pos;}public long getFilePointer() {return cPos;}public long length() throws IOException {return Math.max(cPos, super.length());}public int read() throws IOException {if (cPos >= hi_) {if (isEOF)return -1;seek(cPos);if (cPos == hi_)return -1;}byte res = buffer[(int) (cPos - lo_)];cPos++;return ((int) res) & 0xFF; }public int read(byte[] b) throws IOException {return read(b, 0, b.length);}public int read(byte[] b, int off, int len) throws IOException {if (cPos >= hi_) {if (isEOF)return -1;seek(cPos);if (cPos == hi_)return -1;}len = Math.min(len, (int) (hi_ - cPos));int buffOff = (int) (cPos - lo_);System.arraycopy(buffer, buffOff, b, off, len);cPos += len;return len;}public void write(int b) throws IOException {if (cPos >= hi_) {if (isEOF && hi_ < maxHi_) {hi_++;} else {seek(cPos);if (cPos == hi_) {hi_++;}}}buffer[(int) (cPos - lo_)] = (byte) b;cPos++;hasDatas = true;syncNeeded_ = true;}public void write(byte[] b) throws IOException {write(b, 0, b.length);}public void write(byte[] b, int off, int len) throws IOException {while (len > 0) {int n = writeAtMost(b, off, len);off += n;len -= n;hasDatas = true;syncNeeded_ = true;}}private int writeAtMost(byte[] b, int off, int len) throws IOException {if (cPos >= hi_) {if (isEOF && hi_ < maxHi_) {hi_ = maxHi_;} else {seek(cPos);if (cPos == hi_) {hi_ = maxHi_;}}}len = Math.min(len, (int) (hi_ - cPos));int buffOff = (int) (cPos - lo_);System.arraycopy(b, off, buffer, buffOff, len);cPos += len;return len;}}

最终，用一个小例子来验证其工作效率，我们将比较RandomAccessFile，BufferedRandomAccessFile，BufferedInput/OutputStream的效率。

package RandomIO;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.RandomAccessFile;public class RandomIOTest2 {public static void main(String[] args) {long startTime;long endTime;File source = new File("./src/file/test.avi");File target = new File("./src/file/testcopy.avi");byte[] buffer = new byte[1024];startTime = System.currentTimeMillis();int len;try (RandomAccessFile sourceFile = new RandomAccessFile(source, "rw");RandomAccessFile targetFile = new RandomAccessFile(target, "rw")) {while ((len = sourceFile.read(buffer)) != -1) {targetFile.write(buffer, 0, len);}endTime = System.currentTimeMillis();System.out.println("RandomAccessFile拷贝耗时" + (endTime - startTime)+ "ms");} catch (Exception e) {}startTime = System.currentTimeMillis();try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(target));) {while ((len = bis.read(buffer)) != -1) {bos.write(buffer, 0, len);}endTime = System.currentTimeMillis();System.out.println("BufferedInputStream/BuffedOutputStream拷贝耗时"+ (endTime - startTime) + "ms");} catch (Exception e) {}startTime = System.currentTimeMillis();try (BufferedRandomAccessFile1 sourceFile = new BufferedRandomAccessFile1(source, "rw");BufferedRandomAccessFile1 targetFile = new BufferedRandomAccessFile1(target, "rw")) {while ((len = sourceFile.read(buffer)) != -1) {targetFile.write(buffer, 0, len);}endTime = System.currentTimeMillis();System.out.println("BufferedRandomAccessFile1拷贝耗时" + (endTime - startTime)+ "ms");} catch (Exception e) {}}}

执行上述代码，可以看到以下输出结果：

从输出中可以看出，RandomAccessFile的效率确实很低，但加上缓存后，工作效率立马提升。
以上为本篇内容。