程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> Java RandomAccessFile的用法詳解

Java RandomAccessFile的用法詳解

編輯：關於JAVA

Java RandomAccessFile的用法詳解。本站提示廣大學習愛好者：（Java RandomAccessFile的用法詳解）文章只能為提供參考，不一定能成為您想要的結果。以下是Java RandomAccessFile的用法詳解正文

RandomAccessFile

RandomAccessFile是用來拜訪那些保留數據記載的文件的，你便可以用seek( )辦法來拜訪記載，並停止讀寫了。這些記載的年夜小不用雷同；然則其年夜小和地位必需是可知的。然則該類僅限於操作文件。

RandomAccessFile不屬於InputStream和OutputStream類系的。現實上，除完成DataInput和 DataOutput接口以外(DataInputStream和DataOutputStream也完成了這兩個接口)，它和這兩個類系絕不相關，乃至不應用InputStream和OutputStream類中曾經存在的任何功效；它是一個完整自力的類，一切辦法(絕年夜多半都只屬於它本身)都是從零開端寫的。這能夠是由於RandomAccessFile能在文件外面前後挪動，所以它的行動與其它的I/O類有些基本性的分歧。總而言之，它是一個直接繼續Object的，自力的類。

根本上，RandomAccessFile的任務方法是，把DataInputStream和DataOutputStream聯合起來，再加上它本身的一些辦法，好比定位用的getFilePointer( )，在文件裡挪動用的seek( )，和斷定文件年夜小的length( )、skipBytes()跳過量少字節數。另外，它的結構函數還要一個表現以只讀方法("r")，照樣以讀寫方法("rw")翻開文件的參數 (和C的fopen( )如出一轍)。它不支撐只寫文件。

只要RandomAccessFile才有seek搜索辦法，而這個辦法也只實用於文件。BufferedInputStream有一個mark( )辦法，你可以用它來設定標志(把成果保留在一個外部變量裡)，然後再挪用reset( )前往這個地位，然則它的功效太弱了，並且也不怎樣適用。

RandomAccessFile的絕年夜多半功效，但不是全體，曾經被JDK 1.4的nio的"內存映照文件(memory-mapped files)"給代替了，你該斟酌一下是否是用"內存映照文件"來取代RandomAccessFile了。

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數據 
      rf.writeDouble(i * 1.414); 
    } 
    rf.close(); 
    rf = new RandomAccessFile("rtest.dat", "rw"); 
    //直接將文件指針移到第5個double數據前面 
    rf.seek(5 * 8); 
    //籠罩第6個double數據 
    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(); 
  } 
}

內存映照文件

內存映照文件能讓你創立和修正那些由於太年夜而沒法放入內存的文件。有了內存映照文件，你便可以以為文件曾經全體讀進了內存，然後把它當做一個異常年夜的數組來拜訪。這類處理方法能年夜年夜簡化修正文件的代碼。

fileChannel.map(FileChannel.MapMode mode, long position, long size)將此通道的文件區域直接映照到內存中。留意，你必需指明，它是從文件的哪一個地位開端映照的，映照的規模又有多年夜；也就是說，它還可以映照一個年夜文件的某個小片段。

MappedByteBuffer是ByteBuffer的子類，是以它具有了 ByteBuffer的一切辦法，但新添了force()將緩沖區的內容強迫刷新到存儲裝備中去、load()將存儲裝備中的數據加載到內存中、 isLoaded()地位內存中的數據能否與存儲設置上同步。這裡只簡略地演示了一下put()和get()辦法，除此以外，你還可使用 asCharBuffer( )之類的辦法獲得響應根本類型數據的緩沖視圖後，可以便利的讀寫根本類型數據。

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來創立文件。 
    FileChannel fc = new RandomAccessFile("test.dat", "rw").getChannel(); 
    //留意，文件通道的可讀可寫要樹立在文件流自己可讀寫的基本之上 
    MappedByteBuffer out = fc.map(FileChannel.MapMode.READ_WRITE, 0, length); 
    //寫128M的內容 
    for (int i = 0; i < length; i++) { 
      out.put((byte) 'x'); 
    } 
    System.out.println("Finished writing"); 
    //讀取文件中央6個字節內容 
    for (int i = length / 2; i < length / 2 + 6; i++) { 
      System.out.print((char) out.get(i)); 
    } 
    fc.close(); 
  } 
}

雖然映照寫仿佛要用到FileOutputStream，然則映照文件中的一切輸入必需應用RandomAccessFile，但假如只須要讀時可使用FileInputStream，寫映照文件時必定要應用隨機拜訪文件，能夠寫時要讀的緣由吧。

該法式創立了一個128Mb的文件，假如一次性讀到內存能夠招致內存溢出，但這裡拜訪似乎只是一剎時的事，這是由於，真正調入內存的只是個中的一小部門，其他部門則被放在交流文件上。如許你便可以很便利地修正超年夜型的文件了(最年夜可以到2 GB)。留意，Java是挪用操作體系的"文件映照機制"來晉升機能的。

RandomAccessFile類的運用：

/* 
 * 法式功效：演示了RandomAccessFile類的操作，同時完成了一個文件復制操作。 
 */ 
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文件中寫數據 
 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 拔出寫示例：

/** 
 * 
 * @param skip 跳過量少過字節停止拔出數據 
 * @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("跳過字節數有效"); 
      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(); 
  } 
}

應用RandomAccessFile完成文件的多線程下載，即多線程下載一個文件時，將文件分紅幾塊，每塊用分歧的線程停止下載。上面是一個應用多線程在寫文件時的例子，個中事後分派文件所須要的空間，然後在所分派的空間中停止分塊，然後寫入：

import java.io.FileNotFoundException; 
import java.io.IOException; 
import java.io.RandomAccessFile; 
 
/** 
 * 測試應用多線程停止文件的寫操作 
 */ 
public class Test { 
 
  public static void main(String[] args) throws Exception { 
    // 預分派文件所占的磁盤空間，磁盤中會創立一個指定年夜小的文件 
    RandomAccessFile raf = new RandomAccessFile("D://abc.txt", "rw"); 
    raf.setLength(1024*1024); // 預分派 1M 的文件空間 
    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) { 
        } 
      } 
    } 
  } 
 
}

以上這篇Java RandomAccessFile的用法詳解就是小編分享給年夜家的全體內容了，願望能給年夜家一個參考，也願望年夜家多多支撐。