Java RandomAccessFile

1. 介绍

   RandomAccessFile的唯一父类是Object，与其他流父类不同。是用来访问那些保存数据记录的文件的，这样你就可以用seek( )方法来访问记录，并进行读写了。这些记录的大小不必相同；但是其大小和位置必须是可知的。
   RandomAccessFile是不属于InputStream和OutputStream类系的。实际上，除了实现DataInput和DataOutput接口之外(DataInputStream和DataOutputStream也实现了这两个接口)，它和这两个类系毫不相干，甚至都没有用InputStream和OutputStream已经准备好的功能；它是一个完全独立的类，所有方法(绝大多数都只属于它自己)都是从零开始写的。这可能是因为RandomAccessFile能在文件里面前后移动，所以它的行为与其它的I/O类有些根本性的不同。总而言之，它是一个直接继承Object的，独立的类。

2. 工作方式

   基本上，RandomAccessFile的工作方式是，把DataInputStream和DataOutputStream粘起来，再加上它自己的一些方法，比如定位用的getFilePointer( )，在文件里移动用的seek( )，以及判断文件大小的length( )。此外，它的构造函数还要一个表示以只读方式(“r”)，还是以读写方式(“rw”)打开文件的参数 (和C的fopen( )一模一样)。它不支持只写文件，从这一点上看，假如RandomAccessFile继承了DataInputStream，它也许会干得更好。
   只有RandomAccessFile才有seek方法，而这个方法也只适用于文件。BufferedInputStream有一个mark( )方法，你可以用它来设定标记(把结果保存在一个内部变量里)，然后再调用reset( )返回这个位置，但是它的功能太弱了，而且也不怎么实用 RandomAccessFile的绝大多数功能，如果不是全部的话，已经被JDK1.4的nio的”内存映射文件(memory-mapped files)”给取代了。

3. 实例

import java.io.IOException;
import java.io.RandomAccessFile;

public class FileDemo {
    public static void main(String[] args) throws IOException{
        RandomAccessFile raf= new RandomAccessFile("raf.dat","rw");

        // long getFilePointer()获取当前RAF的指针位置
        long p=raf.getFilePointer();
        System.out.println(p);//output 0
        raf.write(97);
        System.out.println(raf.getFilePointer());//output 1

        //连续写4个字节
        raf.writeInt(1);
        System.out.println(raf.getFilePointer());//output 5

        //void seek(long position)从文件的某个地方读取字节,需要先将指针移动到这个位置
        raf.seek(0);
        //读取字节
        int n=raf.read();
        System.out.println(n);
        System.out.println(raf.getFilePointer());//output 1

        //跳过1个字节
        raf.skipBytes(1);
        int i = raf.readInt();
        System.out.println(i);

        raf.close();
    }

1. 内存映射文件

   内存映射文件能让你创建和修改那些因为太大而无法放入内存的文件。有了内存映射文件，你就可以认为文件已经全部读进了内存，然后把它当成一个非常大的数组来访问。这种解决办法能大大简化修改文件的代码。
   fileChannel.map(FileChannel.MapMode mode, long position, long size)将此通道的文件区域直接映射到内存中。注意，你必须指明，它是从文件的哪个位置开始映射的，映射的范围又有多大；也就是说，它还可以映射一个大文件的某个小片断。
   MappedByteBuffer是ByteBuffer的子类，因此它具备了ByteBuffer的所有方法，但新添了force()将缓冲区的内容强制刷新到存储设备中去、load()将存储设备中的数据加载到内存中、isLoaded()位置内存中的数据是否与存储设置上同步。这里只简单地演示了一下put()和get()方法，除此之外，你还可以使用asCharBuffer( )之类的方法得到相应基本类型数据的缓冲视图后，可以方便的读写基本类型数据。

   1. 实例

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;  
import java.nio.channels.FileChannel; 

public class FileDemo {
    static int length=0x8000000;//128M
    public static void main(String[] args) throws IOException{
        RandomAccessFile raf= new RandomAccessFile("raf.dat","rw");
        FileChannel fc=raf.getChannel();
        //文件通道的可读可写要建立在文件流本身可读写的基础之上 
        MappedByteBuffer out=fc.map(FileChannel.MapMode.READ_WRITE, 0, length);
        //写内容
        for(int i=0;i<length;i++){
            out.put((byte)'x');
        }
        //读取文件中间n个字节内容 
        for (int i = length / 2; i < length / 2 + 16; i++) {  
            System.out.print((char) out.get(i));  
        }  
        fc.close();  
    }
}

尽管映射写似乎要用到FileOutputStream，但是映射文件中的所有输出 必须使用RandomAccessFile，但如果只需要读时可以使用FileInputStream，写映射文件时一定要使用随机访问文件，Java是调用操作系统的”文件映射机制”来提升性能。

import java.io.IOException;
import java.io.RandomAccessFile;

public class FileDemo {
    static int length=0x8000000;//128M
    public static void main(String[] args) throws IOException{
        RandomAccessFile file= new RandomAccessFile("raf.dat","rw");

        // 以下向file文件中写数据 
          file.writeInt(20);// 占4个字节 
          file.writeDouble(8.236598);// 占8个字节 
          file.writeUTF("这是一个UTF字符串");// 这个长度写在当前文件指针的前两个字节处，可用readShort()读取 
          file.writeBoolean(true);// 占1个字节 
          file.writeShort(395);// 占2个字节 
          file.writeLong(2325451l);// 占8个字节 
          file.writeUTF("又是一个UTF字符串");  
          file.writeFloat(35.5f);// 占4个字节 
          file.writeChar('a');// 占2个字节 

          file.seek(0);// 把文件指针位置设置到文件起始处 

          // 以下从file文件中读数据，要注意文件指针的位置 
          System.out.println("——————从file文件指定位置读数据——————");  
          System.out.println(file.readInt());  
          System.out.println(file.readDouble());  
          System.out.println(file.readUTF());  

          file.skipBytes(3);// 将文件指针跳过3个字节，本例中即跳过了一个boolean值和short值。 
          System.out.println(file.readLong());  

          file.skipBytes(file.readShort()); // 跳过文件中“又是一个UTF字符串”所占字节，注意readShort()方法会移动文件指针，所以不用加2。 
          System.out.println(file.readFloat());  

          //以下演示文件复制操作 
          System.out.println("——————文件复制（从file到fileCopy）——————");  
          file.seek(0);  
          RandomAccessFile fileCopy=new RandomAccessFile("fileCopy","rw");  
          int len=(int)file.length();//取得文件长度（字节数） 
          byte[] b=new byte[len];  
          file.readFully(b);  
          fileCopy.write(b);  
          System.out.println("复制完成！");  
    }
}

用RandomAccessFile实现文件的多线程下载，即多线程下载一个文件时，将文件分成几块，每块用不同的线程进行下载。下面是一个利用多线程在写文件时的例子，其中预先分配文件所需要的空间，然后在所分配的空间中进行分块，然后写入：

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class FileDemo {
    public static void main(String[] args) throws IOException{
         // 预分配文件所占的磁盘空间，磁盘中会创建一个指定大小的文件 
        RandomAccessFile raf = new RandomAccessFile("abc.txt", "rw");  
        raf.setLength(2048*2048); // 预分配4M 的文件空间 
        raf.close();  

        // 所要写入的文件内容 
        String s1 = "第一个字符串";  
        String s2 = "第二个字符串";  
        String s3 = "第三个字符串";  
        String s4 = "第四个字符串";  
        String s5 = "第五个字符串";  

        // 利用多线程同时写入一个文件 
        new FileWriteThread(1024*1,s1.getBytes()).start(); // 从文件的1024字节之后开始写入数据 
        new FileWriteThread(1024*2,s2.getBytes()).start(); // 从文件的2048字节之后开始写入数据 
        new FileWriteThread(1024*3,s3.getBytes()).start(); // 从文件的3072字节之后开始写入数据 
        new FileWriteThread(1024*4,s4.getBytes()).start(); // 从文件的4096字节之后开始写入数据 
        new FileWriteThread(1024*5,s5.getBytes()).start(); // 从文件的5120字节之后开始写入数据 
    }  

    // 利用线程在文件的指定位置写入指定数据 
    static class FileWriteThread extends Thread{  
        private int skip;  
        private byte[] content;  

        public FileWriteThread(int skip,byte[] content){  
            this.skip = skip;  
            this.content = content;  
        }  

        public void run(){  
            RandomAccessFile raf = null;  
            try {  
                raf = new RandomAccessFile("D://abc.txt", "rw");  
                raf.seek(skip);  
                raf.write(content);  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block 
                e.printStackTrace();  
            } finally {  
                try {  
                    raf.close();  
                } catch (Exception e) {  
                }  
            }  
        }   
    }
}