主体：

?

RandomAccessFile类。其I/O性能较之其它常用开发语言的同类性能差距甚远，严重影响程序的运行效率。

开发人员迫切需要提高效率，下面分析RandomAccessFile等文件类的源代码，找出其中的症结所在，并加以改进优化，创建一个"性/价比"俱佳的随机文件访问类BufferedRandomAccessFile。

?

在改进之前先做一个基本测试：逐字节COPY一个12兆的文件（这里牵涉到读和写）。

?

?

我们可以看到两者差距约32倍，RandomAccessFile也太慢了。先看看两者关键部分的源代码，对比分析，找出原因。

?

1．1．[RandomAccessFile]

?

public class RandomAccessFile implements DataOutput, DataInput {
	public final byte readByte() throws IOException {
		int ch = this.read();
		if (ch < 0)
			throw new EOFException();
		return (byte)(ch);
	}
	public native int read() throws IOException; 
	public final void writeByte(int v) throws IOException {
		write(v);
	} 
	public native void write(int b) throws IOException; 
}

?

可见，RandomAccessFile每读/写一个字节就需对磁盘进行一次I/O操作。

?

1．2．[BufferedInputStream]

?

public class BufferedInputStream extends FilterInputStream {
	private static int defaultBufferSize = 2048; 
	protected byte buf[]; // 建立读缓存区
	public BufferedInputStream(InputStream in, int size) {
		super(in);        
		if (size <= 0) {
			throw new IllegalArgumentException("Buffer size <= 0");
		}
		buf = new byte[size];
	}
	public synchronized int read() throws IOException {
		ensureOpen();
		if (pos >= count) {
			fill();
			if (pos >= count)
				return -1;
		}
		return buf[pos++] & 0xff; // 直接从BUF[]中读取
	} 
	private void fill() throws IOException {
	if (markpos < 0)
	    pos = 0;		/* no mark: throw away the buffer */
	else if (pos >= buf.length)	/* no room left in buffer */
	    if (markpos > 0) {	/* can throw away early part of the buffer */
		int sz = pos - markpos;
		System.arraycopy(buf, markpos, buf, 0, sz);
		pos = sz;
		markpos = 0;
	    } else if (buf.length >= marklimit) {
		markpos = -1;	/* buffer got too big, invalidate mark */
		pos = 0;	/* drop buffer contents */
	    } else {		/* grow buffer */
		int nsz = pos * 2;
		if (nsz > marklimit)
		    nsz = marklimit;
		byte nbuf[] = new byte[nsz];
		System.arraycopy(buf, 0, nbuf, 0, pos);
		buf = nbuf;
	    }
	count = pos;
	int n = in.read(buf, pos, buf.length - pos);
	if (n > 0)
	    count = n + pos;
	}
}

1．3．[BufferedOutputStream]

?

public class BufferedOutputStream extends FilterOutputStream {
   protected byte buf[]; // 建立写缓存区
   public BufferedOutputStream(OutputStream out, int size) {
		super(out);
		if (size <= 0) {
			throw new IllegalArgumentException("Buffer size <= 0");
		}
		buf = new byte[size];
    } 
public synchronized void write(int b) throws IOException {
		if (count >= buf.length) {
	   		flushBuffer();
		}
		buf[count++] = (byte)b; // 直接从BUF[]中读取
   }
   private void flushBuffer() throws IOException {
		if (count > 0) {
			out.write(buf, 0, count);
			count = 0;
		}
   }
}

可见，Buffered I/O putStream每读/写一个字节，若要操作的数据在BUF中，就直接对内存的buf[]进行读/写操作；否则从磁盘相应位置填充buf[]，再直接对内存的buf[]进行读/写操作，绝大部分的读/写操作是对内存buf[]的操作。

?

1．3．小结

?

内存存取时间单位是纳秒级（10E-9），磁盘存取时间单位是毫秒级（10E-3）， 同样操作一次的开销，内存比磁盘快了百万倍。理论上可以预见，即使对内存操作上万次，花费的时间也远少对于磁盘一次I/O的开销。 显然后者是通过增加位于内存的BUF存取，减少磁盘I/O的开销，提高存取效率的，当然这样也增加了BUF控制部分的开销。从实际应用来看，存取效率提高了32倍。

?

根据1.3得出的结论，现试着对RandomAccessFile类也加上缓冲读写机制。

?

随机访问类与顺序类不同，前者是通过实现DataInput/DataOutput接口创建的，而后者是扩展F