Java IO 輸入和輸出流

　　數據流是指一組有順序的，有起點和終點的字節集合。

　　最初的版本中，java.io 包中的流只有普通的字節流，即以 byte 為基本處理單位的流。字節流用來讀寫 8 位的數據，由於不會對數據做任何轉換，因此可以用來處理二進制的數據。在后來的版本中，java.io 包中又加入了專門用於字符流處理的類，這個以 Reader 和 Writer 為基礎派生的一系列的類。

　　另外，為了使對象的狀態能夠方便地永久保存下來，java.io 包中又提供了以字節流為基礎的用於對象的永久化保存狀態的機制，通過實現 ObjectInput 和 ObjectOutput 接口來完成。

 

　　InputStream 和 OutputStream 兩個類都是抽象類，抽象類不能進行實例化。在實際應用中我們要用到一系列基本數據流類，都是他們的子類，在實現其父類方法的同時又都定義了其特有的功能。

• 輸入數據流

• • 輸入數據流中提供的主要數據操作方法

    • int read()：從輸入流中讀取一個字節的二進制數據
    • int read(byte[] b)：將多個字節讀到數組中，填滿整個數組
    • int read(byte[] b, int off, int len)：從輸入流中讀取長度為len的數據，從數組 b 中下標為 off 的位置開始放置讀入的數據，讀畢返回讀取的字節數
    • 以上三個方法中，所讀取的數據都默認為字節類型。當輸入流讀取結束時，會得到 -1，以標志數據流的結束。第一個 read() 方法將讀取的一個字節作為低位，形成一個 0~255 的 int 類型的數值返回
    • void close()：關閉數據流
    • long skip(long l)：跳過數據流中指定數量的字節不讀取，返回值表示實際跳過的字節數
    • 對於數據流中的字節的讀取通常是按從頭到尾順序進行的，如果需要以反方向讀取，則需要使用回推（Push Back）操作，支持回推操作的數據流中常用的方法如下
    • boolean markSupported()：用於測試數據流是否支持回推操作，當一個數據流支持 mark() 和 reset() 方法時返回 true，否則返回 false
    • void mark(int markarea)：用於標記數據流的當前位置，並划出一個緩沖區，其大小至少為指定參數的大小
    • void reset()：將輸入流重新定位到對此流最后調用 mark 方法時的位置

• 輸出數據流

  • 輸出數據流中提供的主要數據操作方法
    

    • void write(int i)：將字節 i 寫入到數據流中，它只輸出所讀入參數的最低 8 位
    • void write(byte b[])：將數組 b[] 中的全部 b.length 個字節寫入數據流
    • void write(byte b[], int off, int len)：將數組 b[] 中從下標 off 開始的 len 個字節寫入數據流。元素 b[off] 是此操作寫入的第一個字節， b[off + len - 1] 是此操作寫入的最后一個字節
    • void close()：當結束對輸出數據流的操作時應該將其關閉
    • void flush()：刷新此輸出流並強制寫出所有緩沖的輸出字節

基本字節數據流類

---

 

• 文件數據流

  • 文件數據流包括 FileInputStream 和 FileOutputStream，這兩個類用來進行文件的I/O處理，其數據源或數據終點都應當是文件。通過所提供的方法可以對本機上的文件進行操作，但是不支持方法 mark() 和 reset()

  • 示例(1)

    • FileInputStream fis = new FileInputStream("myFile.txt");
      // 同樣可以使用 FileOutputStream  向文件中輸出字節
      FIleOutputStream out = new FileOutputStream("myFile.txt");

• • 示例(2)

    • FIleOutputStream out = new FileOutputStream("myFile.txt");
      out.wirte('H');
      out.wirte(69);
      out.wirte(76);
      out.wirte('L');
      out.wirte('O');
      out.close();

      FIleInputStream fis = new FileInputStream("myFile.txt");
      while(fis.available() > 0){
          System.out.print(fis.read() + " ");
      }
      fis.close();

• 過濾器數據流(直接繼承與FilterInputStream、FilterOutputStream)

  • 緩沖區數據流
    

    • 一個過濾器數據流在創建時與一個已經存在的數據流相連，這樣在從這樣的數據流中讀取數據時，它提供的是對一個原始輸入數據流的內容進行了特定處理的數據。緩沖區數據流有BufferedInputStream 和 BufferedOutinputStream，它們是在數據流上增加了一個緩沖區，都屬於過濾器數據流。當讀寫數據時，數據以塊為單位先進入緩沖區（塊大小可以進行設置），其后的讀寫操作則作用於緩沖區。采用這個辦法可以降低不同硬件設備之間速度的差異，提高I/O操作的效率
      

    • 示例(使用默認緩沖區大小)

    • FileInputStream fis = new FileInputStream("myFile.txt");
      InputStream is = new BufferedInputStream(fis);
      FileOutputStream fos = new FileOutputStream("myFile.txt");
      OutputStream is = new BufferedOutputStream(fos);

    • 示例(自定義設置緩沖區大小)

    • FileInputStream fis = new FileInputStream("myFile.txt");
      InputStream is = new BufferedInputStream(fis, 1024);
      FileOutputStream fos = new FileOutputStream("myFile.txt");
      OutputStream is = new BufferedOutputStream(fos, 1024);

    • 一般在關閉一個緩沖區輸出流之前，應先使用 flush() 方法，強制輸出剩余數據，以確保緩沖區內的所有數據全部寫入輸出流

  • 數據數據流
    

    • 前面提到的數據流中處理數據都是指字節或字節數組，這是進行數據傳輸時系統默認的數據類型。但實際上所處理的數據並非只有這兩種類型，遇到這種情況時就要應用一種專門的數據流來處理。DataInputStream 和 DataOutputStream 就是這樣的兩個過濾器數據流，它們允許通過數據流來讀寫 Java 基本類型
      

    • 示例

    • DataInputStream dis = new DataInputStream(is);
      DataOutputStream ous = new DataOutputStream(os);

    • 常用方法

    • // DataInputStream 常用方法
      
      byte readByte()
      long readLong()
      doublue readDouble()
      boolean readBoolean()
      String readUTF()
      int readInt()
      float readFloat()
      short readShort()
      char readChar()
      
      // DataOutputStream 常用方法
      
      void writeByte(int aByte)
      void writeLong(long aLong)
      void writeDouble(double aBouble)
      void writeBoolean(boolean aBool)
      void writeUTF(String aString)
      void writeInt(int aInt)
      void writeFloat(float aFloat)
      void writeShort(short aShort)
      void rwriteChar(char aChar)

    • 雖然這兩個數據流定義了對字符串進行讀寫的方法，但是由於字符編碼的原因，應該避免使用這些方法。Reader 和 Writer 重載了這兩個方法，對字符進行操作時應當使用 Reader 和 Writer 兩個系列類中的方法

• 對象流
  

  • 能夠輸入/輸出對象的流稱為對象流。Java 通過 java.io 包中的 ObjectInputStream 和 ObjectOutputStream 兩個類實現把對象寫入文件數據流或從文件數據流中讀出的功能
    

  • 示例

  • // 寫對象數據流
    
    Date date = new Date();
    FileOutputStream fos = new FileOutputStream("date.ser");
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(date);
    oos.close();
    
    // 讀對象數據流
    
    Date date = null;
    FileInputStream fis = new FileInputStream("date.ser");
    ObjectInputStream ois = new ObjectInputStream(fis);
    date = (Date) ois.readObject(date);
    ois.close();
    System.out.println("Date serialized at " + date);

• 序列化
  

  • 序列化的概念
    

    • 能夠記錄自己的狀態以便將來得到復原的能力，稱為對象的持久性(Persistence)。一個對象時可持久的，意味着它可以把這個對象存入內存或者磁盤等介質中，也就是把對象存為某種永久存儲類型。對象通過數值來描述自己的狀態，記錄對象也就是記錄下這些數值。把對象轉換為字節序列的過程稱為對象的序列化，把字節序列恢復為對象的過程稱為對象的反序列化。序列化的主要任務是寫出對象實例變量的數值。序列化是一種用來處理對象流的機制，所謂的對象流也就是將對象的內容進行流化。序列化是為了解決在對對象流進行讀寫操作時所引發的問題

  • Serializable 接口中沒有定義任何方法，只是作為一個標記來指示實現該接口的類可以進行序列化，只有實現 Serializable 接口的類才能被序列化。當一個類實現 Serializable 接口時，表明該類加入了對象序列化協議

  • 序列化一個對象，必須與特定的對象輸出/輸入流聯系起來，通過對象輸出流/輸入流將對象狀態保存下來或者將對象狀態恢復。通過 java.io 包中的 ObjectInputStream 和 ObjectOutputStream 兩個類可以實現。writeObject() 和 readObject() 方法可以直接將對象保存到輸出流中或者從輸出流中讀取一個對象

  • // 序列化
    
    public class Student implements Serializable {
        int id;
        String name;
        int age;
        String department;
        public Student(int id, String name, int age, String department) {
            this.id = id;
            this.name = name;
            this.age = age;
            this.department = department;
        }
    }
    
    // 對象的存儲
    
    Student stu = new Student(927103, "Li Ming", 16, "CSD");
    FileOutputStream fo = new FileOutputStream("data.ser");
    ObjectOutputStream so = new ObjectOutputStream(fo);
    so.writeObject(stu);
    so.close();
    
    // 對象的恢復
    
    Student stu;
    FileInputStream fi = new FileInputStream("data.ser");
    ObjectInputStream si = new ObjectInputStream(fi);
    stu = (Student)si.readObject();
    si.close();
    System.out.println("ID:" + stu.id + ";name:" + stu.name);

  • 對象結構表

    • 序列化只能保存對象的非靜態成員變量，而不能保存任何成員方法和靜態成員變量，並且保存的只是變量的值，對於變量的任何修飾符都不能保存，訪問權限（public, protected, private）對於數據域的序列化沒有影響
      
    • 有一些對象不具有可持久性，因為其數據的特性決定了它會經常變化，其狀態只是瞬時的，這樣的對象是無法保存起狀態的，如 Thread 對象。對於這樣的成員變量，必須用 transient 關鍵字標明，否則編譯器將報錯。任何用 transient 關鍵字標明的成員變量都不會被保存
    • 序列化可能涉及將對象存放到磁盤上或者再網絡上發送數據，這時會產生安全問題。對於一些保密的數據，為了保證安全，不應保存在永久介質中，應在這些變量前加上 transient 關鍵字
    • 當數據變量是一個對象時，該對象的數據成員也可以被持久化。對象的數據結構或結構樹，包括其子對象樹在內，構成了這個對象的結構表

  • 示例
    

  • public class Student implements Serializable {
        public transient Thread myThread;
        private transient String customerID;
        private int total;
    }

基本字符流

---

 

　　從 JDK1.1 開始，java.io 包中加入了專門用於字符流處理的類，它們是以 Reader 和 Writer 為基礎派生的一系列類。

　　一、讀者（Reader）和寫者（Writer）

　　　　同其他語言使用 ASCII 字符集不同，Java 使用 Unicode 字符集來表示和字符。ASCII 字符集以一個字節（8bit）表示一個字符，可以認為一個字符就是一個字節（byte）。但是 Java 使用的 Unicode 是一種大字符集，用兩個字節（16bit）來表示一個字符，這時字節與字符就不再相同。為實現與其他程序語言及不同平台的交互，Java 提供一種新的數據流處理方案稱作 Reader 和 Writer。在 java.io 包中有許多不同類對其進行支持，其中最重要的是 InputStreamReader 和 OutputStreamWriter 類。這兩個類是字節流和 Reader 和 Writer 的接口，用來在字節流和字符流之間作為中介。

　　　　在英語國家中，字節編碼采用 ISO8859_1 協議。ISO8859_1 是 Latin-1 編碼系統映射到 ASCII 標准，能夠在不同平台之間正確轉換字符。

// 構造映射到 ASCII 碼的標准的 InputStreamReader 的方法

InputStreamReader ir = new InputStreamReader(System.in, "8859_1");

// Reader 提供的方法

void close();
void mark(int readAheadLimit);
boolean markSupported();
int read();
int read(char[] cbuf);
int read(char[] cbuf, int off, int len);
boolean ready();
void reset();
long skip(long n);

// Writer 提供的方法

void close();
void flush();
void write(char[] cbuf);
void write(char[] cbuf, int off, int len);
void write(int c);
void write(String str);
void write(String str, int off, int len);

　　二、緩沖區讀者和緩沖區寫者

　　　　java.io 中提供流緩沖流 BufferedReader 和 BufferedWriter。其構造方法與 BufferedInputStream 和 BufferedOutputStream 類似。另外，除了 read() 和 write() 方法外，還提供了整行字符的處理方法

• • 方法如下

    • public String readLine()：BufferedReader 的方法，從輸入流中讀取一行字符，行結束標志為 '\n' 、'\r' 或者兩者一起
    • public void newLine()：BufferedWriter 的方法，向輸出流中寫入一個行結束標志

  • 示例

    • FileInputStream fis = new FileInputStream("data.ser");
      InputStreamReader dis = new InputStreamReader(fis);
      BufferedReader reader = new BufferedReader(dis);
      // BufferedReader reader = new BufferedReader(new FileReader("data.ser"));
      String s;
      while((s = reader.readLine()) != null) {
          System.out.println("read:" + s);
      }
      dis.close();

  • 當你寫文件的時候，為了提高效率，寫入的數據會先放入緩沖區，然后寫入文件。因此有時候你需要主動調用 flush()方法

    • // FileWriter
      FileWriter fw = new FileWriter("D:/Test.txt");
      String s = "hello world";
      fw.write(s, 0, s.length());
      fw.flush(); //flush將緩沖區內容寫入到問題件
      // OutputStreamWriter
      OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:/Test1.txt"));
      osw.write(s, 0, s.length());
      osw.flush();
      // PrintWriter
      PrintWriter pw = new PrintWriter(new OutputStreamWriter(new
      FileOutputStream("D:/Test2.txt")), true);
      // PrintWriter pw = new PrintWriter(new FileWriter("D:/Test2.txt"));
      
      pw.println(s); 
      
      // close AllWriter 
      
      fw.close(); 
      osw.close(); 
      pw.close();

  • 文件拷貝

    • File file = new File("D:/Test.txt");
      File dest = new File("D:/new.txt");
      try {
          BufferedReader reader = new BufferedReader(new FileReader(file));
          BufferedWriter writer = new BufferedWriter(new FileWriter(dest)); 
          String line = reader.readLine();
          while(line!=null){
              writer.write(line);
              line = reader.readLine();
          }
          writer.flush();
          reader.close();
          writer.close();
      } catch (FileNotFoundException e) {
          e.printStackTrace();
      } catch (IOException e) {
          e.printStackTrace();
      }