Java之IO流總結

　　序言-

　　第一次寫博客，雖然工作快兩年了，一直沒想起來去分享什么，后來聽同事說，沒事喜歡去寫寫博客，我覺得，作為一個程序員，應該具備分享精神，所以覺得從基礎開始，給剛接觸Java的同學，一點點小小i的幫助，也算給自己溫故而知新的機會。

　　下面開始我們的Java學習之旅吧。

    IO流
·Java流式輸入/輸出原理
·Java流類的分類
·輸入/輸出流類
·常見的節點流和處理流
·文件流
·緩沖流
·轉換流
·數據流
·Print流
·Object流

①Java流式輸入/輸出原理
    
        00101...-->
    文件 ------------------ 程序

        <-- ...00101
    文件 ------------------ 程序
    
           00101...-->
    網絡連接 ------------------ 程序

        00101...-->
    程序 ------------------ 程序

         00101...-->  “Hello”
    文件 -----------============== 程序 （從0101等轉換為字符，一層包一層）

②流的分類
    java.io包中
        ·按數據流的方向不同可以分為輸入流、輸出流
        ·按處理數據單位不同可以分為字節流、字符流
        ·按照功能不同可以分為節點流、處理流

    所有流類型位於包java.io內都分別繼承以下四種抽象流類型

            字節流        字符流
    ------------------------------------------
    輸入流          InputStream      Reader
    輸出流          OutputSteam      Writer


        字節流（8bit）

             |----FileInputStream(節點流)
             |
             |----PipedInputStream(節點流)     |---LineNumberInputStream(處理流)
             |                          |       
             |----FilterInputStream(處理流)-------|---DataInputStream(處理流)
             |                     |
    InputStream -|----ByteArrayInputStream(節點流)    |---BufferedInputStream(處理流)
             |                     |---PushbackInputStream(處理流)        
             |----SequenceInputStream(處理流)
             |
             |----StringBufferInputStream(節點流)
             |
             |----ObjectInputStream(處理流)

InputStream的基本方法
        //讀取一個字節並以整數的形式返回（0-255）
        //如果返回-1已到輸入流的末尾
    ·int read() throws IOExcetion

        //讀取一系列字節並存儲到一個數組buffer
        //返回實際讀取的字節數，如果讀取器前已到輸入流的末尾返回-1
    ·int read(byre[] buffer) throws IOExcetion

        //讀取length個字節
        //並存儲到一個字節數組buffer，從length位置開始
        //返回實際讀取的字節數，如果讀取前已到輸入流的末尾返回-1
        //buffer - 讀入數據的緩沖區。
        //offset - 數組 buffer 中將寫入數據的初始偏移量。
        //length - 要讀取的最大字節數。
    ·int read(byte[] buffer, int offset, int length) throws IOExcetion

        //關閉流釋放內存資源
    ·void close() throws IOExcetion

        //跳過n個字節不讀，返回實際跳過的字節數
    ·long skip(long n) throws IOExcetion


        字節流（8bit）

             |----FileOutputStream(節點流)
             |
             |----PipedOutputStream(節點流)    
             |                          |       
             |----FilterOutputStream(處理流)-----|---DataOutputStream(處理流)
             |                     |
       OutputStream -|----ByteArrayOutputStream(節點流)  |---BufferedOutputStream(處理流)
             |                     |---PrintStream(處理流)        
             |
             |----ObjectOutputStream(處理流)

OutputStream的基本方法
        //向輸出流中寫入一個字節數據，該字節數據為參數b的低8位
    ·void write(int b) throws IOException
    
        //將一個字節類型的數組中的數據寫入輸出流
    ·void write(byre[] b) throws IOException

        //將一個字節類型的數組中的從指定位置（off）開始的len個字節寫入到輸出流
    ·void write(byre[] b, int off, int len) throws IOException

        //關閉流釋放內存資源
    ·void close() throws IOException

        //將輸出流中緩沖的數據全部寫出到目的地
    ·void flush() throws IOException

    注意：先flush，在close



        字符流（16bit）

             |----BufferedReader(節點流)----LineNumberReader(處理流)
             |
             |----CharArrayReader(處理流)    
             |                              
             |----InputStreamReader(處理流)-----FileReader(節點流)
             |                    
             Reader -|----FilterReader(處理流)----PushbackReader(處理流)
             |                         
             |
             |----PipedReader(節點流)
             |
             |----StringReader(節點流)


Reader的基本方法
        //讀取一個字符並以整數的形式返回（0-255）
        //如果返回-1已到輸入流的末尾
    ·int read() throws IOExcetion

        //讀取一系列字符並存儲到一個數組buffer
        //返回實際讀取的字符數，如果讀取器前已到輸入流的末尾返回-1
    ·int read(byre[] buffer) throws IOExcetion

        //讀取length個字符
        //並存儲到一個字符數組buffer，從length位置開始
        //返回實際讀取的字符數，如果讀取前已到輸入流的末尾返回-1
        //buffer - 讀入數據的緩沖區。
        //offset - 數組 buffer 中將寫入數據的初始偏移量。
        //length - 要讀取的最大字符數。
    ·int read(byte[] buffer, int offset, int length) throws IOExcetion

        //關閉流釋放內存資源
    ·void close() throws IOExcetion

        //跳過n個字符不讀，返回實際跳過的字節數
    ·long skip(long n) throws IOExcetion


        字符流（16bit）

             |----BufferedWriter(處理流)
             |
             |----CharArrayWriter(節點流)    
             |                              
             |----OutputStreamReader(處理流)-----FileWriter(節點流)
             |                    
             Writer -|----FilterWriter(處理流)
             |                         
             |
             |----PipedWriter(節點流)
             |
             |----StringWriter(節點流)

Writer的基本方法
        //向輸出流中寫入一個字符數據，該字節數據為參數b的低8位
    ·void write(int b) throws IOException
    
        //將一個字符類型的數組中的數據寫入輸出流
    ·void write(char[] cbuf) throws IOException

        //將一個字符類型的數組中的從指定位置（off）開始的len個字符寫入到輸出流
    ·void write(char[] cbuf, int off, int len) throws IOException

        //將一個字符串中的字符寫入到輸出流
    ·void write(String string) throws IOException

        //將一個字符串從offset開始的length個字符寫入到輸出流
    ·coid write(String string, int offset, int length) throws IOException

        //關閉流釋放內存資源
    ·void close() throws IOException

        //將輸出流中緩沖的數據全部寫出到目的地
    ·void flush() throws IOException


③輸入/輸出流
    1、輸出流跟輸入流
    一切以程序為中心
        ·從文件到程序為輸入流
        ·從程序到文件為輸出流
    2、字節流和字符流
        ·字節（8bit）
        ·字符（16bit）
        ·一個字符等於2個字節
    3、節點流和處理流
        ·處理流是包在節點流的一層“管道”

④常見的節點流和處理流
    ·節點流為可以從一個特定的數據源（節點）讀寫數據（如：文件，內存）
            節點流
        數據源 -------------------- 程序
        
    ·處理流是連接在已存在的流（節點流或處理流）之上，通過對數據的處理為程序提供更為強大的讀寫功能

            -->
        數據源 -------======== 程序
            
            <--
        程序 ============-------- 數據源

⑤節點流----文件流
    字符流            字節流
---------------------------------------
輸入流    FileReader    FileInputStream
輸出流    FileWriter    FileOutputStream

訪問文件
    從文件到程序，輸入流
    ·使用FileInputStream

        public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        try {
            //連接管道
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //讀取數據
            try {
                while((b = fis.read())!= -1){
                    System.out.print((char)(b));
                    
                }
                fis.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}
    顯示結果
    package Demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        try {
            //????????
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //????????
            try {
                int num = 0;
                while((b = fis.read())!= -1){
                    System.out.print((char)(b));
                }
                fis.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}

    發現出現？？？？？，問題是漢字是一個字符（兩個字節），用的是字節流，一個字節一個字節讀取，
所有中文翻譯不出來，改為Reader可以
    
    從程序到文件
    ·使用FileOutputStream
    package Demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        FileOutputStream fot = null;
        try {
            //連接管道
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
            fot = new FileOutputStream("C://Users//woshishabi//Desktop//test.txt");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //讀取數據
            try {
                while((b = fis.read())!= -1){
                    fot.write(b);
                }
                fis.close();
                fot.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}

    桌面上多了一個Test.txt文本，


    ·使用FileReader：字符輸入流，從文件到程序
        ......
    ·使用FileWriter：字符輸出流，從程序到文件
        ......

⑥處理流----緩沖流
    ·緩沖流要“套接”在相應的節點流之上，對讀寫的數據提供了緩沖的功能，提高了讀寫的效率，
同時增加了一些新的方法
    ·J2SDK提供了四種緩存流，其常用的構造方法為：
            //字符輸入緩沖流
        BufferedReader(Reader in)
        BufferedReader(Reader in, int sz) //sz為自定義緩存區的大小    
            
            //字符輸出緩沖流
        BufferedWriter(Writer out)
        BufferedWriter(Writer out,int sz)
        
            //字節輸入緩沖流
        BufferedInputStream(InputStream in)
        BufferedInputStream(InputStream in, int size)
    
            //字節輸出緩沖流
        BufferedOutputStream(OutputStream out)
        BufferedOutputStream(OutputStream out, int size)

    ·緩沖輸入流支持其父類的mark和reset方法    mark：直接從多少個字符開始讀取  reset：回到剛才標記的點
    ·bufferedReader提供了readline方法用於讀取一行字符串（以\r或\n分隔）
    ·bufferedWriter提供了newLine用於寫入一個行分隔符
    ·對於輸出的緩沖流，寫出的數據會現在內存中緩存，使用flush方法將會使內存中的數據立刻寫出

bufferedReader和bufferedWriter使用

package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Login{
    public static void main(String[] args){
        try {
            //從文件寫入數據
            BufferedReader br  = new BufferedReader(new FileReader("G://Java2014Project//JavaDemo1//src//Demo01//Login.java"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("C://Users//woshishabi//Desktop//Test.txt"));
            //從文件讀取數據
            String s = null;
            while((s = br.readLine()) != null){
                System.out.println(s);
                bw.write(s);
                bw.newLine();
            }
            bw.flush();
            br.close();
            bw.close();
        }
            catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
    }
}


⑦處理流----轉換流
    ·InputStreamReader和OutputStreamWriter用與字節數據到字符數據之間的轉換
    ·InputStreamReader需要和InputStream“套接”
    ·OutputStream需要和OutputStream“套接”
    ·轉換流在構造時可以指定其編碼集合，例如
        InputStream isr = new InputStreamReader(System.in, "ISO8859_1");

范例：OutputStreamWriter

    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        try {
            //將輸出字節流轉換為字符流
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt"));
            //向文件中輸入字符串
            osw.write("sdfjaksldjflskdjflaskdjfsakjdf");
            //讀取字符編碼
            System.out.println(osw.getEncoding());
            osw.close();
            //在文本后面添加字符串，不覆蓋，則true，否則寫false， 后面可以自定義編碼
            osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt", true), "UTF-8");
            osw.write("qwqeqweqweqeq");
            System.out.println(osw.getEncoding());
            osw.close();
        }
            catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }

范例：InputStreamReader

    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        //從鍵盤讀取數據
        InputStreamReader isr = new InputStreamReader(System.in);
        //字符輸入緩沖流
        BufferedReader br = new BufferedReader(isr);
        String s = null;
        try {
            //讀取一行字符
            s = br.readLine();
            while(s != null){
            if(s.equalsIgnoreCase("exit")){     //將一個字符串與另一個字符串比較，不考慮大小寫
                break;    
            }
            //將小寫轉換為大寫
                System.out.println(s.toUpperCase());
                s = br.readLine();
            }
            br.close();
            
            }
         catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}


⑧數據流----DataInputStream...
    ·DataInputStream 和 DataOutputStream 分別繼承了InputStream 和 OutputStream，屬於處理流，
需要分別套接在InputStream 和 OutputStream類型的節點流觴
    ·DataInputStream 和 DataOutputStream 提供了可以存取與機器無關的Java原始數據類型（int、double等）
的方法
    ·DataInputStream 和 DataOutputStream 的構造方法為：
        ·DataInputStream（InputStream in）
        ·DataOutputStream（OutputStream out）
    
范例：使用DataInputStream 和 DataOutputStream
package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        //一個字節數組輸出流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //在字節數組輸出流上套接一個數據流，能傳遞基本數據類型
        DataOutputStream dos = new DataOutputStream(baos);
        try {
            //向字節數組寫入一個隨機數
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            //創建一個字節數組輸入流
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            //輸出字節數組中有多少個字節
            System.out.println(bais.available());
            //將處理流包在字節數組輸入流上，輸出基本數據
            DataInputStream dis = new DataInputStream(bais);
            //輸出double，先輸入的先輸出
            System.out.println(dis.readDouble());
            //輸出boolean
            System.out.println(dis.readBoolean());
            dos.close();
            dis.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

    
⑨print流    PrintStream主要操作byte流，而PrintWriter用來操作字符流
    ·PrintWriter 和 PrintStream都屬於輸出流，分別針對與字符和字節
    ·PrintWriter 和 PrintStream提供了重載的print
    ·Println方法用於多種數據類型的輸出
    ·PrintWriter 和 PrintStream的輸出操作不會拋出異常，用戶通過檢測錯誤狀態獲取錯誤信息
    ·PrintWriter 和 PrintStream有自動flush功能
構造方法：
    ·PrintWriter(Writer out)
    ·PrintWriter(Writer out，boolean autoFlush)
    ·PrintWriter(OutputStream out， boolean autoFlush)
    ·PrintStream(OutputStream out)
    ·PrintStream(OutputStream out， boolean autoFlush)

范例：PrintStream
package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

public class Login{
    public static void main(String[] args){
        PrintStream ps = null;
        try {
            //文件字節輸出流
            FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
            //輸出流
            ps = new PrintStream(fos);
            if(ps != null){
                //使system.out指向了文件Test.txt
                System.setOut(ps);
            }
            for (int i = 0; i < 100; i++) {
                System.out.print(i + ",");
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


范例：PrintWriter

    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Date;

public class Login{
    public static void main(String[] args){
        String s = null;
        //從鍵盤輸入，字節轉字符的轉換流上套接緩沖流
        BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
        try {
            //輸出流，輸出到文件，不覆蓋
            FileWriter fw = new FileWriter("C://Users//woshishabi//Desktop//Test.txt",true);
            //輸出流，套接在文件輸出流上
            PrintWriter pw = new PrintWriter(fw);
            //接收鍵盤輸入的一行數據，
            while((s = bis.readLine()) != null){
                //判斷是否為exit，是則結束while
                if(s.equalsIgnoreCase("exit"))break;
                //小寫轉大寫，在dos中輸出
                System.out.println(s.toUpperCase());
                //在目標文件里面輸出數據
                pw.println("------");
                pw.println(s.toLowerCase());
                pw.flush();
            }
            //在目標文件中輸出日期
            pw.println("-----"+ new Date() + "------");
            pw.flush();
            pw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


⑩Object流
    ·直接將Object寫入或讀出
        ·transient關鍵字（透明的）：修飾屬性， transient int k  = 15;   輸出結果k = 0；在序列化的時候不考慮，不寫入硬盤
        ·serializable接口：（標記性接口，里面什么都沒有）
        ·extemalizable接口：
    注意：如果需要使用對象流，必須實現serializable接口

范例：
    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.Date;

public class Login{
    public static void main(String[] args){
        T t = new T();
        t.k = 40;
        try {
            //文件輸出流，
            FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
            //在文件輸出流上套接一個對象輸出流，從程序傳遞一個對象到目標文件中
            ObjectOutputStream  oos = new ObjectOutputStream(fos);
            //寫入對象
            oos.writeObject(t);
            //文件輸入流，鎖定目標文件
            FileInputStream fis = new FileInputStream("C://Users//woshishabi//Desktop//Test.txt");
            //在文件輸入流上套接一個對象輸入流，從目標文件中取出對象的通道
            ObjectInputStream ois = new ObjectInputStream(fis);

            //取出對象
            T t1 = (T) ois.readObject();
            //打印到屏幕上
            System.out.println(t1.i + " " + t1.j + " " + t1.k + " " + t1.z);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

class T implements Serializable{
    int i = 1;
    int j = 2;
    double z = 9.0;
    int k = 14;

}




總結：
    ·InputStream/OutputStream

    ·Reader/Writer

    ·FileInputStream/FileoutputStream

    ·FileReader/FileWriter

    ·BufferedInputStream/BufferedOutoutStream

    ·BufferedTeader/BufferedWriter

    ·ByteArrayInputStream/ByteArrayOutputStream

    ·InputStreamReader/OutputStreamWriter

    ·DataInputStream/DataOutputStream

    ·PrintStream/PrintWriter

    ·ObjectInputStream/ObjectOutputStream