Java中的輸入輸出流

InputStream和OutputStream是字節輸入輸出流的頂級父類，用於操作字節流。InputStream是輸入流，負責讀。OutputStream是輸出流，負責寫。Reader和Writer是字符輸入輸出流的頂級父類，用於操作字符流。Reader是負責讀。Writer是負責寫。、下面逐個講解一下各個的方法：

• 用普通讀取方法讀取，每次只讀取一個字節

        FileReader fr = new FileReader("123.txt"); // 明確被讀取的文件 使其相關聯  
        //如果len是-1，則證明讀到了結尾  
        //如果len是一個數字，這個數字代表的是讀取到的字符的ASCII碼值  
        // System.out.println(buf.toString());打印出來的是哈希值  
        int len=0;  
        while ((len=fr.read())!=-1) {  
            System.out.print((char)len);  
        }  
        //fr.read();// 的返回結果是讀取到到字符  
        fr.close(); 

• 在上一步的基礎上，利用緩衝區進行讀取，每次讀取一個定義的數組的長度

        /* 
         * 需求：演示Reader中的read(char[]);讀取方法。 
         *  
         * 這種讀取的效率要比第一種高的多。 
         *  
         */  
        FileReader fr  = new FileReader("123.txt");  
        //創建一個字符數組。   
        char[] buf = new char[2];  
        int len = 0;  
        //如果讀取到數字，讀取的值大小時讀取到的字符數  
        while((len=fr.read(buf))!=-1){  
            System.out.print(new String(buf,0,len));  
        }  
        fr.close();  

• 同普通方法寫入一個文件：

        FileWriter writer = new FileWriter("123.txt",true);
        //有了則覆蓋,沒有則創建,後面true意思是可以續寫  
        writer.write("123"+LINE_SPARATOR+"www");  
        writer.flush();//緩衝區的東西刷新到目的地中  
        writer.close();//利用到了系統的資源，所以要釋放  
        System.out.println("執行完畢");  

• 用緩衝區高效寫入一個文件：

        //創建一個流對象  
        FileWriter writer = new FileWriter("buffer.txt");  
        //爲了提高效率，創建了一個緩衝區對象，並和要和提高效率的流關聯。  
        BufferedWriter bufwr = new BufferedWriter(writer);  
        //接下來用緩衝區方法進行操作  操作數組中的數據  數據都跑在了緩衝區當中  
        bufwr.write("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");  
        bufwr.newLine();  
        bufwr.write("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");  
        bufwr.close();//底層是關閉的流對象  本來這句只是關閉一個數組  
        System.out.println("執行完畢");  

• 有以上例子我們做出複製一個文件的例子

        FileReader reader = null;  
        FileWriter writer = null;  
        try {  
            reader = new FileReader("123.txt");// 讀取數據  
            writer = new FileWriter("copy123.txt");  
            char ch[] = new char[1024];  
            int len = 0;// 返回值是讀取到的字符數  
            while ((len = reader.read(ch)) != -1) {  
                writer.write(ch, 0, len);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
            throw new RuntimeException("出現異常");  
        } finally {  
            if (reader != null) {  
                try {  
                    reader.close();  
                } catch (IOException e) {  
                    // 相關代碼處理 比如說記錄到日誌文件當中  
                    throw new RuntimeException("輸入流關閉失敗");  
                }  
            }  
            if (writer != null) {  
                try {  
                    writer.close();  
                } catch (IOException e) {  
                    throw new RuntimeException("輸出流關閉失敗");  
                }  
            }  
        }  

• 上面那個是自己寫了一個數組，作爲緩衝區，當然Java設計者也不會那麼笨，所以本身提供了緩衝區進行讀- 寫操作：
  下面我們看一個例子（底層就是裝飾設計模式）:

        FileReader reader=null;  
        FileWriter writer = null;  
        BufferedReader fr=null;  
        BufferedWriter fw=null;  
        try {  
            reader = new FileReader("buffer.txt");  
            writer = new FileWriter("copybuffer.txt");  
            fr = new BufferedReader(reader);  
            fw = new BufferedWriter(writer);  
            String line=null;  
            while ((line=fr.readLine())!=null) {  
                fw.write(line);  
                fw.newLine();//讀一行寫一行   所以要換行  
            }  
        } catch (Exception e) {  
        }finally{  
            try {  
                fr.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            try {  
                fw.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
        System.out.println("執行完畢");  

---

InputStream和OutputStream是字節輸入輸出流的頂級父類，用於操作字節流。InputStream是輸入流，負責讀。OutputStream是輸出流，負責寫。它本身爲一個抽象類，必須依靠其子類實現各種功能，此抽象類是表示字節輸入流的所有類的超類。 繼承自InputStream 的流都是 向程序中 輸入數據的，且數據單位爲字節（8bit）

用輸入流緩衝區高效讀取數據：

        FileInputStream fis = new FileInputStream("bytestream.txt");  
        System.out.println(fis.available());  
        byte[] buf = new byte[2048];//一個漢字是兩個字節 如果沒有用數組讀  漢字沒法讀出來 因爲一次只讀了y  
        //一個字節  半個漢字   輸出的是？  
        int len = 0;  
        while ((len=fis.read(buf))!=-1) {  
            System.out.println(new String(buf,0,len));  
        }  
        fis.close();  

下面看一下用數組高效的賦值文件：

public class CopyMp3A {  
    public static void main(String[] args) throws IOException {  
        FileInputStream reader   = new FileInputStream("1.mp3");  
        FileOutputStream writer = new FileOutputStream("2.mp3");  
        byte  b[]= new byte[reader.available()];  
        reader.read(b);  
        //在這裏來一個形象的比喻，reader讀取文件，這個文件的大小已經知道了  用一個數組b圈了起來 這是這個文件對外就變成了一個b  
        //然後調用read方法讀取這個文件把他給放到一個流中  這個時候在調用write方法進入這個六中拿到這個b  
        writer.write(b);  
        reader.close();  
        writer.close();  
        System.out.println("執行完畢");  
    }  

轉換流