Java———較大二進位文件的讀、寫

　　由於項目需要，需要對二進位文件進行讀寫、轉換。

　　文件說明：由其他程式得到的二進位文件，文件內容為：包含23543個三角形、13270個頂點的三角網所對應的721組流速矢量（u、v）文件，通俗些說，一條數據包含兩個雙精度型的數值，每組數組包含23543條數據，如果以一個雙精度數值為單位，則總共有23543 * 721 * 2 =33,949,006條數據。由Fortran程式以每 8 Byte存儲一個數值的二進位文件存儲，最終文件大小為下圖所示：

 　　測試：從該文件讀出數據之後，轉換為十進位，存儲到另一個文件中。

/**
 * 針對大文件存儲，請依次調用beginSave、AddSave、endSave。
 * 
 * @author CK
 *
 */
public class DataUtil {

    DataOutputStream BinaryOut=null;
    BufferedWriter TextOut=null;
    String FilePath=null;
    enum SaveFileType{Text,Binary};
    SaveFileType SaveFileType;

    /**
     * double轉byte[]
     * 
     * @param d
     * @return
     */
    public static byte[] double2Bytes(double d) {
        long value = Double.doubleToRawLongBits(d);
        byte[] byteRet = new byte[8];
        for (int i = 0; i < 8; i++) {
            byteRet[i] = (byte) ((value >> 8 * i) & 0xff);
        }
        return byteRet;
    }

    /**
     * byte[]轉double
     * 
     * @param arr
     * @return
     */
    public static double bytes2Double(byte[] arr) {
        long value = 0;
        for (int i = 0; i < 8; i++) {
            value |= ((long) (arr[i] & 0xff)) << (8 * i);
        }
        return Double.longBitsToDouble(value);
    }
    /**
     * 大型數據存儲之開始存儲
     * @param FilePath 文件路徑
     * @param saveFileType 保存的文件類型，文本文件、雙精度所存的二進位文件
     * @return
     * @throws IOException
     */
    public boolean BeginSave(String FilePath,SaveFileType saveFileType) throws IOException {
        if (FilePath == "" || FilePath == null) {
            System.out.println("the SavePath is null.");
            return false;
        }
        this.FilePath=FilePath;
        this.SaveFileType=saveFileType;
        File dataFile = new File(FilePath);
        if (!dataFile.getParentFile().exists()) {
            dataFile.getParentFile().mkdirs();
        }
        if (dataFile.exists()) {
            dataFile.delete();
        }
        dataFile.createNewFile();
        switch(this.SaveFileType){
        case Text:
            TextOut=  new BufferedWriter(new FileWriter(dataFile,true));
            break;
        case Binary:
            BinaryOut = new DataOutputStream(new FileOutputStream(dataFile,true));
            break;
        default:
            break;
            
        }        
        return true;
    }
/**
 * 大型文件存儲之追加存儲
 * @param DataStr  若是文本存儲則無要求，若是雙精度的二進位文件，以若幹空格隔開
 * @return
 * @throws IOException
 */
    public boolean AddSave(String DataStr) throws IOException{
        switch(this.SaveFileType){
        case Text:
            this.TextOut.append(DataStr);
            break;
        case Binary:
            DataStr=DataStr.trim();
            String[] dataArray=DataStr.split("\\s+");
            for(int i=0;i<dataArray.length;i++){
                this.BinaryOut.write(double2Bytes(Double.parseDouble(dataArray[i])));
            }                    
            break;
        default:
            break;
        
        }
        
        return true;
    }
    /**
     * 大型文件存儲之結束保存，清空緩存、關閉文件。
     * @return
     * @throws IOException
     */
    public boolean EndSave() throws IOException{
        switch(this.SaveFileType){
        case Text:
            this.TextOut.flush();
            this.TextOut.close();
            break;
        case Binary:
            this.BinaryOut.flush();
            this.BinaryOut.close();
            break;
        default:
            break;        
        }
        
        return true;
    }
  /**
     * 將字元串保存為文本文件（一次完成）
     * 
     * @param DataStr
     *            文件內容
     * @param SavePath
     *            文件路徑，包含文件名、尾碼
     * @return
     * @throws IOException
     */
    public boolean saveTextFile(String DataStr, String SavePath)
            throws IOException {
        if (DataStr == "" || DataStr == null) {
            System.out.println("the dataStr is null.");
            return false;
        }
        if (SavePath == "" || SavePath == null) {
            System.out.println("the SavePath is null.");
            return false;
        }
        File dataFile = new File(SavePath);
        if (!dataFile.getParentFile().exists()) {
            dataFile.getParentFile().mkdirs();
        }
        if (dataFile.exists()) {
            dataFile.delete();
        }
        dataFile.createNewFile();
        BufferedWriter out;

        out = new BufferedWriter(new FileWriter(dataFile));

        out.append(DataStr);
        out.flush();
        out.close();

        return true;
    }

    /**
     * 雙精度存為二進位數據（一次存儲）
     * 
     * @param DataStr  雙精度數據組成的字元串，以若幹空格隔開
     * @param OutputPath
     * @return
     * @throws IOException
     */
    public boolean saveBinaryFile(String DataStr, String OutputPath) throws IOException {

        if (DataStr == "" || DataStr == null) {
            System.out.println("the dataStr is null.");
            return false;
        }
        if (OutputPath == "" || OutputPath == null) {
            System.out.println("the OutputPath is null.");
            return false;
        }
        File dataFile = new File(OutputPath);

        if (!dataFile.getParentFile().exists()) {
            dataFile.getParentFile().mkdirs();
        }
        if (dataFile.exists()) {
            dataFile.delete();
        }
        dataFile.createNewFile();
        DataOutputStream out;
        out = new DataOutputStream(new FileOutputStream(dataFile));
        // 數據處理
        DataStr=DataStr.trim();
        String[] dataArray=DataStr.split("\\s+");
        for(int i=0;i<dataArray.length;i++){
            out.write(double2Bytes(Double.parseDouble(dataArray[i])));
        }        
        out.flush();
        out.close();
        return true;

    }
}

　　代碼說明：其中byte[]與double互轉為在互聯網上查到的方法，具體是哪位大神的我忘記了，在這裡為了記錄就貼出來啦，上述代碼包含了處理小型文件時，將所有內容存在緩存中，之後再一次性寫入文本文件、二進位文件中的方法，還包含了對較大型文件的讀寫方法，下麵是自己的一個讀寫測試。

/**
 * 測試二進位大文件讀寫（200M左右）
 * @author ck
 *
 */
public class FileTest {
    static String inputFilePath="";  //輸入文件路徑，包含文件名尾碼
    static String outputFilePath=""; //輸出文件名，包含文件名尾碼
    
    public static void  file2file() throws IOException{
        DataUtil dataUtil=new DataUtil(); 
         DataInputStream br=new DataInputStream(  
                 new BufferedInputStream(  
                 new FileInputStream(inputFilePath)));  
                dataUtil.BeginSave(outputFilePath, SaveFileType.Text); //初始化，創建文件，採用文件追加存儲的思路
                 byte[] oneData=new byte[8];
                 int i=0,count =0 ;
                while(br.read(oneData, 0, 8)!=-1){    
                    i=i+1;
                    dataUtil.AddSave(String.valueOf(DataUtil.bytes2Double(oneData)));                    
                    if(i/23543==0){
                        count++;
                        System.out.println(count+"\n");

                    }
                }
                dataUtil.EndSave();       //將還在緩存中的數據寫入到文件中，關閉文件。 
    }
}

 此次測試代碼很快就run完了，但是輸出文件的生成大概用了近半分鐘（刻意秒錶計時了一次），嘗試用一次性讀寫的辦法，卡很久，也沒有出結果。所得的十進位文本文件，大小為這麼多：

　　我想，原來Fortran程式作者的初衷應該是覺得二進位存儲比十進位節省空間吧，事實上也確實節省了一半多的空間。

　　恩，此次記錄完畢。