import java.io.IOException; 
import java.io.RandomAccessFile; 
 
public class TestRandomAccessFile { 
  public static void main(String[] args) throws IOException { 
    RandomAccessFile rf = new RandomAccessFile("rtest.dat", "rw"); 
    for (int i = 0; i < 10; i++) { 
      //寫入基本類型double數(shù)據(jù) 
      rf.writeDouble(i * 1.414); 
    } 
    rf.close(); 
    rf = new RandomAccessFile("rtest.dat", "rw"); 
    //直接將文件指針移到第5個double數(shù)據(jù)后面 
    rf.seek(5 * 8); 
    //覆蓋第6個double數(shù)據(jù) 
    rf.writeDouble(47.0001); 
    rf.close(); 
    rf = new RandomAccessFile("rtest.dat", "r"); 
    for (int i = 0; i < 10; i++) { 
      System.out.println("Value " + i + ": " + rf.readDouble()); 
    } 
    rf.close(); 
  } 
}  

import java.io.RandomAccessFile; 
import java.nio.MappedByteBuffer; 
import java.nio.channels.FileChannel; 
 
public class LargeMappedFiles { 
  static int length = 0x8000000; // 128 Mb 
 
  public static void main(String[] args) throws Exception { 
    // 為了以可讀可寫的方式打開文件，這里使用RandomAccessFile來創(chuàng)建文件。 
    FileChannel fc = new RandomAccessFile("test.dat", "rw").getChannel(); 
    //注意，文件通道的可讀可寫要建立在文件流本身可讀寫的基礎之上 
    MappedByteBuffer out = fc.map(FileChannel.MapMode.READ_WRITE, 0, length); 
    //寫128M的內(nèi)容 
    for (int i = 0; i < length; i++) { 
      out.put((byte) 'x'); 
    } 
    System.out.println("Finished writing"); 
    //讀取文件中間6個字節(jié)內(nèi)容 
    for (int i = length / 2; i < length / 2 + 6; i++) { 
      System.out.print((char) out.get(i)); 
    } 
    fc.close(); 
  } 
} 

/* 
 * 程序功能：演示了RandomAccessFile類的操作，同時實現(xiàn)了一個文件復制操作。 
 */ 
package com.lwj.demo; 
 
import java.io.*; 
 
public class RandomAccessFileDemo { 
 public static void main(String[] args) throws Exception { 
 RandomAccessFile file = new RandomAccessFile("file", "rw"); 
 // 以下向file文件中寫數(shù)據(jù) 
 file.writeInt(20);// 占4個字節(jié) 
 file.writeDouble(8.236598);// 占8個字節(jié) 
 file.writeUTF("這是一個UTF字符串");// 這個長度寫在當前文件指針的前兩個字節(jié)處，可用readShort()讀取 
 file.writeBoolean(true);// 占1個字節(jié) 
 file.writeShort(395);// 占2個字節(jié) 
 file.writeLong(2325451l);// 占8個字節(jié) 
 file.writeUTF("又是一個UTF字符串"); 
 file.writeFloat(35.5f);// 占4個字節(jié) 
 file.writeChar('a');// 占2個字節(jié) 
 
 file.seek(0);// 把文件指針位置設置到文件起始處 
 
 // 以下從file文件中讀數(shù)據(jù)，要注意文件指針的位置 
 System.out.println("——————從file文件指定位置讀數(shù)據(jù)——————"); 
 System.out.println(file.readInt()); 
 System.out.println(file.readDouble()); 
 System.out.println(file.readUTF()); 
 
 file.skipBytes(3);// 將文件指針跳過3個字節(jié)，本例中即跳過了一個boolean值和short值。 
 System.out.println(file.readLong()); 
 
 file.skipBytes(file.readShort()); // 跳過文件中“又是一個UTF字符串”所占字節(jié)，注意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();//取得文件長度（字節(jié)數(shù)） 
 byte[] b=new byte[len]; 
 file.readFully(b); 
 fileCopy.write(b); 
 System.out.println("復制完成！"); 
 } 
} 

/** 
 * 
 * @param skip 跳過多少過字節(jié)進行插入數(shù)據(jù) 
 * @param str 要插入的字符串 
 * @param fileName 文件路徑 
 */ 
public static void beiju(long skip, String str, String fileName){ 
  try { 
    RandomAccessFile raf = new RandomAccessFile(fileName,"rw"); 
    if(skip < 0 || skip > raf.length()){ 
      System.out.println("跳過字節(jié)數(shù)無效"); 
      return; 
    } 
    byte[] b = str.getBytes(); 
    raf.setLength(raf.length() + b.length); 
    for(long i = raf.length() - 1; i > b.length + skip - 1; i--){ 
      raf.seek(i - b.length); 
      byte temp = raf.readByte(); 
      raf.seek(i); 
      raf.writeByte(temp); 
    } 
    raf.seek(skip); 
    raf.write(b); 
    raf.close(); 
  } catch (Exception e) { 
    e.printStackTrace(); 
  } 
} 

import java.io.FileNotFoundException; 
import java.io.IOException; 
import java.io.RandomAccessFile; 
 
/** 
 * 測試利用多線程進行文件的寫操作 
 */ 
public class Test { 
 
  public static void main(String[] args) throws Exception { 
    // 預分配文件所占的磁盤空間，磁盤中會創(chuàng)建一個指定大小的文件 
    RandomAccessFile raf = new RandomAccessFile("D://abc.txt", "rw"); 
    raf.setLength(1024*1024); // 預分配 1M 的文件空間 
    raf.close(); 
     
    // 所要寫入的文件內(nèi)容 
    String s1 = "第一個字符串"; 
    String s2 = "第二個字符串"; 
    String s3 = "第三個字符串"; 
    String s4 = "第四個字符串"; 
    String s5 = "第五個字符串"; 
     
    // 利用多線程同時寫入一個文件 
    new FileWriteThread(1024*1,s1.getBytes()).start(); // 從文件的1024字節(jié)之后開始寫入數(shù)據(jù) 
    new FileWriteThread(1024*2,s2.getBytes()).start(); // 從文件的2048字節(jié)之后開始寫入數(shù)據(jù) 
    new FileWriteThread(1024*3,s3.getBytes()).start(); // 從文件的3072字節(jié)之后開始寫入數(shù)據(jù) 
    new FileWriteThread(1024*4,s4.getBytes()).start(); // 從文件的4096字節(jié)之后開始寫入數(shù)據(jù) 
    new FileWriteThread(1024*5,s5.getBytes()).start(); // 從文件的5120字節(jié)之后開始寫入數(shù)據(jù) 
  } 
   
  // 利用線程在文件的指定位置寫入指定數(shù)據(jù) 
  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) { 
        } 
      } 
    } 
  } 
 
}