RandomAccessFile 讲解与使用

RandomAccessFile的简介

RandomAccessFile可以实现对文件数据的随机读取。

RandomAccessFile类包含了一个记录指针，用以标识当前读写处的位置，当程序新创建一个RandomAccessFile对象时，该对象的文件记录指针位于文件头（也就是0处）,当读/写了n个字节后，文件记录指针将会向后移动n个字节。除此之外，RandomAccessFile可以自由的移动记录指针，即可以向前移动，也可以向后移动。RandomAccessFile包含了以下两个方法来操作文件的记录指针.

1. long getFilePointer(); 返回文件记录指针的当前位置
2. void seek(long pos); 将文件记录指针定位到pos位置

RandomAccessFile即可以读文件，也可以写，所以它即包含了完全类似于InputStream的3个read()方法，其用法和InputStream的3个read()方法完全一样；也包含了完全类似于OutputStream的3个write()方法，其用法和OutputStream的3个Writer()方法完全一样。除此之外，RandomAccessFile还包含了一系类的readXXX()和writeXXX()方法来完成输入和输出。

RandomAccessFile有两个构造器，其实这两个构造器基本相同，只是指定文件的形式不同而已，一个使用String参数来指定文件名，一个使用File参数来指定文件本身。除此之外，创建RandomAccessFile对象还需要指定一个mode参数。该参数指定RandomAccessFile的访问模式，有以下4个值：

1. “r” 以只读方式来打开指定文件夹。如果试图对该RandomAccessFile执行写入方法，都将抛出IOException异常。
2. “rw” 以读，写方式打开指定文件。如果该文件尚不存在，则试图创建该文件。
3. “rws” 以读，写方式打开指定文件。相对于”rw” 模式，还要求对文件内容或元数据的每个更新都同步写入到底层设备。
4. “rwd” 以读，写方式打开指定文件。相对于”rw” 模式，还要求对文件内容每个更新都同步写入到底层设备。
    

我们平常创建流对象关联文件,开始读文件或者写文件都是从头开始的,不能从中间开始,如果是开多线程下载一个文件我们之前学过的FileWriter或者FileReader等等都无法完成,而当前介绍的RandomAccessFile他就可以解决这个问题,因为它可以指定位置读,指定位置写的一个类,通常开发过程中,多用于多线程下载一个大文件.

RandomAccessFile特点

RandomAccessFile是java Io体系中功能最丰富的文件内容访问类。即可以读取文件内容，也可以向文件中写入内容。但是和其他输入/输入流不同的是，程序可以直接跳到文件的任意位置来读写数据。
  因为RandomAccessFile可以自由访问文件的任意位置，所以如果我们希望只访问文件的部分内容，那就可以使用RandomAccessFile类。
  与OutputStearm,Writer等输出流不同的是，RandomAccessFile类允许自由定位文件记录指针，所以RandomAccessFile可以不从文件开始的地方进行输出，所以RandomAccessFile可以向已存在的文件后追加内容。则应该使用RandomAccessFile。

常用方法

使用RandomAccessFile写入数据

1.  
   public static void main(String[] args) throws IOException {
2.  
   File file = new File("text1.txt");
3.  
   RandomAccessFile raf = new RandomAccessFile(file, "rw");//读写模式
4.  
   //保证长度一致，采用空格填充
5.  
   String names[] = new String[] {"zhangsan","lisi ","wangwu "};
6.  
   int ages[] = new int[] {30,20,16};
7.  
   for(int x = 0 ;x<names.length;x++) {
8.  
   raf.write(names[x].getBytes());
9.  
   raf.writeInt(ages[x]);
10.  
    }
11.  
    raf.close();
12.  
    }

使用RandomAccessFile读取数据

1.  
   public static void main(String[] args) throws IOException {
2.  
   File file = new File("text1.txt");
3.  
   RandomAccessFile raf = new RandomAccessFile(file, "rw");//读写模式
4.  
   {//读取王五的数据,字符串8位，数字4位z
5.  
   raf.skipBytes(24);
6.  
   byte[] data = new byte[8];
7.  
   int len = raf.read(data);
8.  
   System.out.println("姓名："+new String(data,0,len).trim() +
9.  
   ",年龄："+raf.readInt());
10.  
    }
11.  
    {//读取李四的数据,字符串8位，数字4位z
12.  
    raf.seek(12);
13.  
    byte[] data = new byte[8];
14.  
    int len = raf.read(data);
15.  
    System.out.println("姓名："+new String(data,0,len).trim() +
16.  
    ",年龄："+raf.readInt());
17.  
    }
18.  
    {//读取张三的数据,字符串8位，数字4位z
19.  
    raf.seek(0);
20.  
    byte[] data = new byte[8];
21.  
    int len = raf.read(data);
22.  
    System.out.println("姓名："+new String(data,0,len).trim() +
23.  
    ",年龄："+raf.readInt());
24.  
    }
25.  
    raf.close();
26.  
    }

使用RandomAccessFile实现从指定位置读取文件的功能

1.  
   public static void main(String[] args)throws IOException {
2.  
   String filePath="test.txt";
3.  
   RandomAccessFile raf=null;
4.  
   File file=null;
5.  
   try {
6.  
   file=new File(filePath);
7.  
   raf=new RandomAccessFile(file,"r");
8.  
   // 获取 RandomAccessFile对象文件指针的位置，初始位置为0
9.  
   System.out.print("输入内容："+raf.getFilePointer());
10.  
    //移动文件记录指针的位置
11.  
    raf.seek(1000);
12.  
     
13.  
    byte[] b=new byte[1024];
14.  
    int hasRead=0;
15.  
    //循环读取文件
16.  
    while((hasRead=raf.read(b))>0){
17.  
    //输出文件读取的内容
18.  
    System.out.print(new String(b,0,hasRead));
19.  
    }
20.  
    }catch (IOException e){
21.  
    e.printStackTrace();
22.  
    }finally {
23.  
    raf.close();
24.  
    }
25.  
    }

使用RandomAccessFile实现向文件中追加内容的功能

1.  
   public class RandomAccessFileTest2 {
2.  
   public static void main(String[] args)throws IOException {
3.  
   String filePath="test.txt";
4.  
   RandomAccessFile raf=null;
5.  
   File file=null;
6.  
   try {
7.  
   file=new File(filePath);
8.  
   // 以读写的方式打开一个RandomAccessFile对象
9.  
   raf=new RandomAccessFile(file,"rw");
10.  
    //将记录指针移动到该文件的最后
11.  
    raf.seek(raf.length());
12.  
    //向文件末尾追加内容
13.  
    raf.writeChars("这是追加内容。。");
14.  
    }catch (IOException e){
15.  
    e.printStackTrace();
16.  
    }finally {
17.  
    raf.close();
18.  
    }
19.  
    }

使用RandomAccessFile实现向文件指定位置插入内容的功能

注：RandomAccessFile不能向文件的指定位置插入内容，如果直接将文件记录指针移动到中间某位置后开始输出，则新输出的内容会覆盖文件原有的内容，如果需要向指定位置插入内容，程序需要先把插入点后面的内容写入缓存区，等把需要插入的数据写入到文件后，再将缓存区的内容追加到文件后面。

1.  
   /**
2.  
   * 插入文件指定位置的指定内容
3.  
   * @param filePath 文件路径
4.  
   * @param pos 插入文件的指定位置
5.  
   * @param insertContent 插入文件中的内容
6.  
   * @throws IOException
7.  
   */
8.  
   public static void insert(String filePath,long pos,String insertContent)throws IOException{
9.  
   RandomAccessFile raf=null;
10.  
    File tmp=File.createTempFile("tmp",null);
11.  
    tmp.deleteOnExit();
12.  
    try {
13.  
    // 以读写的方式打开一个RandomAccessFile对象
14.  
    raf = new RandomAccessFile(new File(filePath), "rw");
15.  
    //创建一个临时文件来保存插入点后的数据
16.  
    FileOutputStream fileOutputStream = new FileOutputStream(tmp);
17.  
    FileInputStream fileInputStream = new FileInputStream(tmp);
18.  
    //把文件记录指针定位到pos位置
19.  
    raf.seek(pos);
20.  
    raf.seek(pos);
21.  
    //------下面代码将插入点后的内容读入临时文件中保存-----
22.  
    byte[] bbuf = new byte[64];
23.  
    //用于保存实际读取的字节数据
24.  
    int hasRead = 0;
25.  
    //使用循环读取插入点后的数据
26.  
    while ((hasRead = raf.read(bbuf)) != -1) {
27.  
    //将读取的内容写入临时文件
28.  
    fileOutputStream.write(bbuf, 0, hasRead);
29.  
    }
30.  
    //-----下面代码用于插入内容 -----
31.  
    //把文件记录指针重新定位到pos位置
32.  
    raf.seek(pos);
33.  
    //追加需要插入的内容
34.  
    raf.write(insertContent.getBytes());
35.  
    //追加临时文件中的内容
36.  
    while ((hasRead = fileInputStream.read(bbuf)) != -1) {
37.  
    //将读取的内容写入临时文件
38.  
    raf.write(bbuf, 0, hasRead);
39.  
    }
40.  
    }catch (Exception e){
41.  
    throw e;
42.  
    }
43.  
    }
44.  
    public static void main(String[] args)throws IOException {
45.  
    String filePath="test.txt";
46.  
    insert(filePath,1000,"插入指定位置指定内容");
47.  
    }

RandomAccessFile 文件下载

首先创建一个DownLoadThread的类继承Thread,

1.  
   public class DownLoadThread extends Thread {
2.  
   ​
3.  
   private long start;
4.  
   private File src;
5.  
   private long total;
6.  
   private File desc;
7.  
   ​
8.  
   /**
9.  
   *
10.  
    * @param start
11.  
    * 开始下载的位置
12.  
    * @param src
13.  
    * 要下载的文件
14.  
    * @param desc
15.  
    * 要下载的目的地
16.  
    * @param total
17.  
    * 要下载的总量
18.  
    */
19.  
    public DownLoadThread(long start, File src, File desc, long total) {
20.  
    this.start = start;
21.  
    this.src = src;
22.  
    this.desc = desc;
23.  
    this.total = total;
24.  
    }
25.  
    ​
26.  
    @Override
27.  
    public void run() {
28.  
    try {
29.  
    // 创建输入流关联源,因为要指定位置读和写,所以我们需要用随机访问流
30.  
    RandomAccessFile src = new RandomAccessFile(this.src, "rw");
31.  
    RandomAccessFile desc = new RandomAccessFile(this.desc, "rw");
32.  
    ​
33.  
    // 源和目的都要从start开始
34.  
    src.seek(start);
35.  
    desc.seek(start);
36.  
    // 开始读写
37.  
    byte[] arr = new byte[1024];
38.  
    int len;
39.  
    long count = 0;
40.  
    while ((len = src.read(arr)) != -1) {
41.  
    //分三种情况
42.  
    if (len + count > total) {
43.  
    //1.当读取的时候操作自己该线程的下载总量的时候,需要改变len
44.  
    len = (int) (total - count);
45.  
    desc.write(arr, 0, len);
46.  
    //证明该线程下载任务已经完毕,结束读写操作
47.  
    break;
48.  
    } else if (len + count < total) {
49.  
    //2.证明还没有到下载总量,直接将内容写入
50.  
    desc.write(arr, 0, len);
51.  
    //并且使计数器任务累加
52.  
    count += arr.length;
53.  
    } else {
54.  
    //3.证明改好到下载总量
55.  
    desc.write(arr, 0, len);
56.  
    //结束读写
57.  
    break;
58.  
    }
59.  
    }
60.  
    src.close();
61.  
    desc.close();
62.  
    ​
63.  
    } catch (Exception e) {
64.  
    e.printStackTrace();
65.  
    }
66.  
    }
67.  
    }

文件的测试

1.  
   public static void main(String[] args) {
2.  
   //关联源
3.  
   File src = new File("a.txt");
4.  
   //关联目的
5.  
   File desc = new File("b.txt");
6.  
   ​
7.  
   //获取源的总大小
8.  
   long length = src.length();
9.  
   // 开两条线程,并分配下载任务
10.  
    new DownLoadThread(0, src, desc, length / 2).start();
11.  
    new DownLoadThread(length / 2 , src, desc, length - (length / 2)).start();
12.  
    }

总结

从以上分析可以看出RandomAccessFile最大两个特点:

1.可以指定位置开始操作;

2.既可以读,也可以写;

所以,我们但凡遇到不能从中间开始读取的时候,可以使用RandomAccessFile这个类,比如:多线程下载是最常用的应该场景