Java中寫文件操作

---

OutputStream 和 Writer

---

• OutputStream類(直接操作byte數組)

        該類是字節輸出流的抽象類，定義了輸出流的各種操作方法。如下圖是OutputStream的層次結構：

 

• ByteArrayOutputStream:字節數組流，可以捕獲內存緩沖區的數據，轉換為字節數組。該類有兩個構造方法：

     new ByteArrayOutputStream();   

     new ByteArrayOutputStream(int size);    //size表示初始化字節數組緩沖區的大小

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bos.write('q');
        bos.write('a');   //將字節寫入該字符數組   
        bos.reset();      //重置該字節數組，即將如上寫入的'q' 'a'字節清空
        byte[] b = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n'};
        bos.write(b, 1, 7);   //從b數組的第一個下標連續寫入長度為7個字符
        try {
            FileOutputStream fs = new FileOutputStream("SourceFile/employee");
            bos.writeTo(fs);   //將字符數組寫入文檔
            fs.close();
            bos.flush();
            bos.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

• FileOutputStream:以字節流的方式將二進制數據或者字符數據輸出到文件中，該類有5個構造方法，我們在代碼中介紹了2和4的用法：

1. new FileOutputStream(File);
2. new FileOutputStream(FileDescriptor);    //FileDescriptor.out將內容輸出到控制台
3. new FileOutputStream(String);              //String為文件路徑
4. new FileOutputStream(File, boolean);     //boolean為true時，則不覆蓋文件，在文件的末尾添加內容，false則覆蓋文件
5. new FileOutputStream(String, boolean); //同上

        try {
            FileOutputStream fs1 = new FileOutputStream(FileDescriptor.out);
            FileOutputStream fs2 = new FileOutputStream(new File("SourceFile/employee"), true); //在該文件的末尾添加內容
            fs1.write("https://www.cnblogs.com/zhanglei93/".getBytes());   //write()方法可以寫入byte數組、int
            fs1.close();
            fs2.write("https://www.cnblogs.com/zhanglei93/".getBytes());
            fs2.flush();   //清空緩存里的數據，並通知底層去進行實際的寫操作
            fs2.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

•  BufferedOutputStream是一個緩沖數據輸出流接口，類中有一個byte數組，調用write()函數時，首先向這個數組中寫入數據，然后當某些時刻（數組寫滿等）會將這些數組寫入到流之中，該類有兩個構造方法：

new BufferedOutputStream(OutputStream)

new BufferedOutputStream(OutputStream,int)   //int的值規定了byte數組的大小

        try {
            FileOutputStream fs = new FileOutputStream("SourceFile/employee");
            BufferedOutputStream bos = new BufferedOutputStream(fs);
            bos.write("https://www.cnblogs.com/zhanglei93/".getBytes());  //write()方法可以寫入byte數組、int
            fs.close();
            bos.flush();
            bos.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

• PrintStream可以方便的輸出各種類型的數據，該類主要用於操作字節流，且該類的方法不拋出IOException。該類有8個構造方法：

new PrintStream(File);

new PrintStream(OutputStream);

new PrintStream(String);    //文件路徑及名稱

new PrintStream(File, String);   //String  編碼格式

new PrintStream(OutputStream, boolean);   //是否自動刷新

new PrintStream(OutputStream, boolean, String);    //是否自動刷新、編碼格式

new PrintStream(String, String);   //文件路徑及名稱、編碼格式

關於該類的詳細說明見：http://www.cnblogs.com/skywang12345/p/io_16.html 

• Writer類（首先進行decode、encode）

該類是字符輸出流的抽象類，定義了輸出流的各種操作方法。如下圖是Writer的層次結構：

• BufferedWriter通過創建緩沖數組，將寫入內容先存入緩存，該類有2個構造函數：

new BufferedWriter(Writer)

new BufferedWriter(Writer, int)   //int大小為默認數組的大小 

        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter("SourceFile/employee"));
            bw.write("http://www.cnblogs.com/zhanglei93/".toCharArray());   //寫入char數組
            bw.write("http://www.cnblogs.com/zhanglei93/");   //寫入String,還可以寫入int
            CharSequence csq = "http://www.cnblogs.com/zhanglei93/p/5846592.html";
            bw.append(csq, 0, 34);
            bw.close();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

• CharArrayWriter創建char緩沖數組，也有兩個構造函數：

new CharArrayWriter();

new CharArrayWriter(int);

      CharArrayWriter cw = new CharArrayWriter(5);
      for(Employee e : employees){
          try {
              cw.write(e.getName());
              cw.append(e.getSalary() + "");
              cw.write(e.getDate().toString() + "\r\n");
              FileWriter fw = new FileWriter("SourceFile/employee");
              cw.writeTo(fw);
              fw.close();
              cw.close();
          } catch (IOException e1) {
              // TODO Auto-generated catch block
              e1.printStackTrace();
          }
      }

• FileWriter該類包含5個構造方法：

new FileWriter(File)

new FileWriter(FileDescriptor)

new FileWriter(String)

new FileWriter(File, boolean)

new FileWriter(String, boolean)

具體的使用方法見:http://docs.oracle.com/javase/8/docs/api/java/io/FileWriter.html

• PrintWriter該類有8種構造方法：

具體見：http://docs.oracle.com/javase/7/docs/api/java/io/PrintWriter.html

PrintWriter pw = null;
    
    /**
     * PrintWriter(String fileName, String csn)  
     * 創建具有指定文件名稱和字符集且不帶自動行刷新的新 PrintWriter。如不執行pw.close()則不刷新文件內容
     * @param name
     * @param code
     * @param employees
     */
    public void writeData(String name, String code, Employee[] employees){
        try {
            pw = new PrintWriter(name, code);
            writeToFile(pw, employees);
            pw.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    /**
     * PrintWriter(Writer out, boolean autoFlush)  
     * 創建新 PrintWriter, flag = true表示能自動刷新,即不執行pw.close()也會自動刷新內容到文件
     * @param write
     * @param flag
     * @param employees
     */
    public void writeData(Writer write, boolean flag, Employee[] employees){
        pw = new PrintWriter(write, flag);
        writeToFile(pw, employees);
        pw.close();
    }
    
    private void writeToFile(PrintWriter pw, Employee[] employees){
        pw.println(employees.length);
        for(Employee e : employees)
            e.writeEmployee(pw);
    }