前言

InputStream/OutStream流用來處理設備之間的數據傳輸

Java.io 包幾乎包含了所有操作輸入、輸出需要的類。所有這些流類代表了輸入源和輸出目標。

Java.io 包中的流支持很多種格式，比如：基本類型、對象、本地化字符集等等。

一個流可以理解為一個數據的序列。輸入流表示從一個源讀取數據，輸出流表示向一個目標寫數據。

• 流按操作數據分為兩種：字節流與字符流
• 按流向分為：輸入流（InputStream）和輸出流（OutputStream）

Java 為 I/O 提供了強大的而靈活的支持，使其更廣泛地應用到文件傳輸和網絡編程中。

IO流常用基類：

• 字節流的抽象基類：

  InputStream,OutputStream
   
  

• 字符流的抽象基類：

  Reader，Writer
  

註意：由這四個類派生出來的子類名稱都是以其父類名的後綴

如：InputStream的子類FileInputStream

Reader的子類BufferedReader 

1. 控制臺IO

1.1 讀取控制臺輸入

Java 的控制臺輸入由 System.in 完成。

為了獲得一個綁定到控制臺的字符流，你可以把 System.in 包裝在一個 BufferedReader 對象中來創建一個字符流。

下面是創建 BufferedReader 的基本語法：

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 

BufferedReader 對象創建後，我們便可以使用 read() 方法從控制臺讀取一個字符，或者用 readLine() 方法讀取一個字符串。

1.2 從控制臺讀取多字符輸入

從 BufferedReader 對象讀取一個字符要使用 read() 方法，它的語法如下：

int read( ) throws IOException

每次調用 read() 方法，它從輸入流讀取一個字符並把該字符作為整數值返回。 當流結束的時候返回 -1。該方法拋出 IOException。

例子：用 read() 方法從控制臺不斷讀取字符直到用戶輸入 "q"。

// 使用 BufferedReader 在控制臺讀取字符

import java.io.*;

public class BRRead {
  public static void main(String args[]) throws IOException
  {
    char c;
    // 使用 System.in 創建 BufferedReader 
    BufferedReader br = new BufferedReader(new 
                       InputStreamReader(System.in));
    System.out.println("輸入字符, 按下 ‘q‘ 鍵退出。");
    // 讀取字符
    do {
       c = (char) br.read();
       System.out.println(c);
    } while(c != ‘q‘);
  }
}
 

1.3 從控制臺讀取字符串

從標準輸入讀取一個字符串需要使用 BufferedReader 的 readLine() 方法。

下面的程序讀取和顯示字符行直到你輸入了單詞"end"。

格式是：

String readLine( ) throws IOException



// 使用 BufferedReader 在控制臺讀取字符
import java.io.*;
public class BRReadLines {
  public static void main(String args[]) throws IOException
  {
    // 使用 System.in 創建 BufferedReader 
    BufferedReader br = new BufferedReader(new
                            InputStreamReader(System.in));
    String str;
    System.out.println("Enter lines of text.");
    System.out.println("Enter ‘end‘ to quit.");
    do {
       str = br.readLine();
       System.out.println(str);
    } while(!str.equals("end"));
  }
}

JDK 5 後的版本我們也可以使用 Java Scanner 類來獲取控制臺的輸入。

1.4 控制臺輸出

控制臺的輸出由 print( ) 和 println() 完成。這些方法都由類 PrintStream 定義，System.out 是該類對象的一個引用。

PrintStream 繼承了 OutputStream類，並且實現了方法 write()。這樣，write() 也可以用來往控制臺寫操作。

PrintStream 定義 write() 的最簡單格式如下所示：

void write(int byteval)

該方法將 byteval 的低八位字節寫到流中。

例子:用 write() 把字符 "A" 和緊跟著的換行符輸出到屏幕：

import java.io.*;

// 演示 System.out.write().
public class WriteDemo {
   public static void main(String args[]) {
      int b; 
      b = ‘A‘;
      System.out.write(b);
      System.out.write(‘\n‘);
   }
}

註意：write() 方法不經常使用，因為 print() 和 println() 方法用起來更為方便。

2. 文件的操作

一個流被定義為一個數據序列。輸入流用於從源讀取數據，輸出流用於向目標寫數據。

描述輸入流和輸出流的類層次圖:

兩個重要的流是 FileInputStream 和 FileOutputStream：

2.1 FileInputStream

2.1.1 創建

該流用於從文件讀取數據，它的對象可以用關鍵字 new 來創建。

有多種構造方法可用來創建對象。

可以使用字符串類型的文件名來創建一個輸入流對象來讀取文件：

InputStream f = new FileInputStream("res/text.txt");

也可以使用一個文件對象來創建一個輸入流對象來讀取文件。我們首先得使用 File() 方法來創建一個文件對象：

File f = new File("res/text.txt");
InputStream out = new FileInputStream(f);

2.1.2 操作

public void close() throws IOException{}
關閉此文件輸入流並釋放與此流有關的所有系統資源。拋出IOException異常。

protected void finalize()throws IOException {}
這個方法清除與該文件的連接。確保在不再引用文件輸入流時調用其 close 方法。拋出IOException異常。

public int read(int r)throws IOException{}
這個方法從 InputStream 對象讀取指定字節的數據。返回為整數值。返回下一字節數據，如果已經到結尾則返回-1。

public int read(byte[] r) throws IOException{}
這個方法從輸入流讀取r.length長度的字節。返回讀取的字節數。如果是文件結尾則返回-1。

public int available() throws IOException{}
返回下一次對此輸入流調用的方法可以不受阻塞地從此輸入流讀取的字節數。返回一個整數值。

除了FileInputStream還有其它常用的流：

• ByteArrayInputStrea
• DataInputStream

2.2 FileOutputStream

2.2.1 創建

該類用來創建一個文件並向文件中寫數據。

如果該流在打開文件進行輸出前，目標文件不存在，那麽該流會創建該文件。

有兩個構造方法可以用來創建 FileOutputStream 對象。

使用字符串類型的文件名來創建一個輸出流對象：

OutputStream f = new FileOutputStream("res/text.txt")

也可以使用一個文件對象來創建一個輸出流來寫文件。我們首先得使用File()方法來創建一個文件對象：

File f = new File("res/text.txt");
OutputStream f = new FileOutputStream(f);

2.2.2 操作

public void close() throws IOException{}
關閉此文件輸入流並釋放與此流有關的所有系統資源。拋出IOException異常。

protected void finalize()throws IOException {}
這個方法清除與該文件的連接。確保在不再引用文件輸入流時調用其 close 方法。拋出IOException異常。

public void write(int w)throws IOException{}
這個方法把指定的字節寫到輸出流中。

public void write(byte[] w)
把指定數組中w.length長度的字節寫到OutputStream中。

擴展：

FileInputStream和FileOutputStream

File總結

除了FileOutputStream外，還有一些其他的常用輸出流：

• ByteArrayOutputStream
• DataOutputStream

實例1：

import java.io.*;

public class FileStreamTest {
    public static void main(String[] args) throws Exception{
        //輸出流
        byte[] bWrite = {1,97,3,65,0,48};
        OutputStream os = new FileOutputStream("res/text.txt");
        for (int i = 0; i < bWrite.length; i++) {
            os.write(bWrite[i]);
        }
        os.close();

        //輸入流
        InputStream is = new FileInputStream("res/Text.txt");
        int size = is.available();
        for (int i = 0; i < bWrite.length; i++) {
            System.out.println((char)is.read());
        }
        is.close();
    }
}

上面的程序首先創建文件test.txt，並把給定的數字以二進制形式寫進該文件，同時輸出到控制臺上。

實例2： 以上代碼由於是二進制寫入，可能存在亂碼，你可以使用以下代碼實例來解決亂碼問題：

package com.rimi.test;

import java.io.*;

public class FileStreamTest {
    public static void main(String[] args) throws IOException{
            //輸出流
            byte[] bWrite = {1,97,3,65,0,48};
            OutputStream os = new FileOutputStream("res/text.txt");
            for (int i = 0; i < bWrite.length; i++) {
                os.write(bWrite[i]);
            }
            os.close();

            //輸入流
            InputStream is = new FileInputStream("res/Text.txt");
            int size = is.available();
            for (int i = 0; i < bWrite.length; i++) {
                System.out.println((char)is.read());
            }
            is.close();


            //構建FileOutputStream對象,文件不存在會自動新建
            File f = new File("res/text1.txt");
            FileOutputStream fos = new FileOutputStream(f);

            // 構建OutputStreamWriter對象,參數可以指定編碼,默認為操作系統默認編碼,windows上是gbk
            OutputStreamWriter oswWriter = new OutputStreamWriter(fos);

            // 寫入到緩沖區
            oswWriter.append("中文輸入");

            //換行
            oswWriter.append("\r\n");

            //寫入到緩沖區
            oswWriter.append("Chinese");

            // 刷新緩沖區,寫入到文件,如果下面已經沒有寫入的內容了,直接close也會寫入
            oswWriter.flush();

            //關閉寫入流,同時會把緩沖區內容寫入文件,所以上面的註釋掉
            oswWriter.close();

            // 關閉輸出流,釋放系統資源
            fos.close();

            //構建FileInputStream對象
            FileInputStream fis = new FileInputStream(f);

            //構建InputStreamReader對象，編碼與寫入相同
            InputStreamReader isReader = new InputStreamReader(fis,"UTF-8");

            StringBuffer sb = new StringBuffer();
            while (isReader.ready()) {
                //讀取的數字轉換為char加入sb中
                sb.append((char)isReader.read());
            }

            //關閉讀取流
            isReader.close();

            //關閉輸入流
            fis.close();

            System.out.println(sb);
    }


}

InputStreamReader和OutputStreamWriter

2.2.3 復制文件（非文本）

public static void main(String[] args) {
    try {
        InputStream fis = new FileInputStream("C:\\Users\\hasee\\Pictures\\54f962a8a20a9.jpg");
        OutputStream fos = new FileOutputStream("res/pic1.jpg");
        int ch = 0;//一個一個讀
        while ((ch = fis.read()) != -1) {
            fos.write(ch);
        }
        fis.close();
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

還可以一次讀一個數組

//裝進數組讀
    byte[] bt = new byte[1024];
    int ch = 0;
    while((ch = fis.read(bt)) != -1){
    System.out.println(new String(bt,0,ch));
    }
//裝進一個剛剛好的數組裏讀
//返回下一次對此輸入流調用的方法可以不受阻塞地從此輸入流讀取（或跳過）的估計剩余字節數。
//簡單講：返回就是字節數
   int num = fis.available();
// System.out.println(num);
//定義一個剛剛好的緩沖區，省掉循環
   byte[] bt = new byte[num];
   fis.read(bt);

思路：

1. 用字節讀取流對象和圖片關聯。
2. 用字節寫入流對象創建一個圖片文件，用語存儲獲取到的圖片數據
3. 通過循環讀寫，完成數據的存儲
4. 關閉資源

註意java中相對路徑用/，絕對路徑要用\

2.2.4 字節流緩沖區

public static void main(String[] args) {
    // try {
    // InputStream fis = new
    // FileInputStream("C:\\Users\\hasee\\Pictures\\54f962a8a20a9.jpg");
    // OutputStream fos = new FileOutputStream("res/pic1.jpg");
    // int ch = 0;//一個一個讀
    // while ((ch = fis.read()) != -1) {
    // fos.write(ch);
    // }
    // fis.close();
    // fos.close();
    // } catch (IOException e) {
    // e.printStackTrace();
    // }

    long starttime = System.currentTimeMillis();
    try {
        copy();
    } catch (IOException e) {
        e.printStackTrace();
    }
    long endtime = System.currentTimeMillis();
    System.out.println("所需時間：" + (endtime - starttime) + "毫秒");
}

// 通過字節流緩沖區完成復制
public static void copy() throws IOException {
    BufferedInputStream bis = new BufferedInputStream(
            new FileInputStream("res/Curtis Stigers & The Forest Rangers - This Life.mp3"));
    BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream("res/temp.mp3"));
    int ch = 0;
    while ((ch = bis.read()) != -1) {
        bos.write(ch);
    }
    bis.close();
    bos.close();
}

2.3 FileWriter和FileReader

FileWriter類 和 FileReader類的一些基本用法

緩沖讀寫的BufferedWriter和BufferedReader

擴展：java中為什麽BufferedReader，BufferedWriter 要比 FileReader 和 FileWriter高效？

2.3.1 創建文件並寫入內容

    FileWriter fw = null;
    try {
     // 創建一個 FileWriter 實例對象，文件寫句柄，
        fw = new FileWriter("res/text2.txt");
         // 創建一個 BufferedWriter 實例對象，獲取文件的寫入句柄，向文件裏面寫入信息
        BufferedWriter bw = new BufferedWriter(fw);
        //通過write()方法往文件裏面寫入信息。
        bw.write("你好！hello world！");
        //關閉
        bw.close();
        fw.close();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

2.3.2 讀取文件

    FileReader fr;
    try {
    // FileReader 創建一個文件讀句柄
        fr = new FileReader("res/text2.txt");
    //創建一個文件內容讀取句柄,讀取文件內容
        BufferedReader br = new BufferedReader(fr);
        String str = null ;
        try {
                while((str = br.readLine()) != null){
                    System.out.println(str);
                }
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

2.3.3 刪除文件

    File file =  new File("res/text.txt");
    if(file.delete()){
        System.out.println(file.getName()+"刪除成功！");
    }else{
        System.out.println("刪除失敗！");
    }

2.3.4 往文件添加數據

    // 直接寫會把裏面的內容覆蓋掉
    try {
        FileWriter fw = new FileWriter("res/text2.txt", true);//apend參數true，添加模式
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("\n你上午好" + new Date());
        bw.close();

        FileReader fr = new FileReader("res/text2.txt");
        char[] chr = new char[1024];
        int num = 0;
        while ((num = fr.read(chr)) != -1) {
            System.out.println(new String(chr, 0, num));
        }

        fw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

2.3.5 創建臨時文件

    File file = new File("res/temp.txt");
    if(file.exists()){
        System.out.println("文件已存在");
    }else{
        System.out.println("文件不存在");
    //  創建一個新的文件
        try {
            file.createNewFile();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("成功創建文件");
    //  程序結束自動刪除
        file.deleteOnExit();
    }

2.3.6 獲取/修改文件最後修改時間

獲取文件最後修改時間

    File file = new File("res/text1.txt");
    Date date = new Date(file.lastModified());
    SimpleDateFormat sformat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    System.out.println("文件最後修改日期：" +  sformat.format(date));

修改文件最後修改時間

    File file = new File("res/text1.txt");
    Date date = new Date(file.lastModified());
    SimpleDateFormat sformat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    System.out.println("文件創建日期：" +  sformat.format(date));
    System.out.println(file.setLastModified(System.currentTimeMillis()));
    date = new Date(file.lastModified());
    System.out.println("文件修改日期：" +  sformat.format(date));

2.3.7 判斷文件是否存在

 File file = new File("res/temp.txt");
 System.out.println("文件是否存在：" + file.exists());  

2.3.8 計算文件大小

    File file = new File("res/text2.txt");
    //file.exists()判斷文件是否存在，有則返回true
    //file.isFile()表示文件是否是一個標準文件
    if (!file.exists() || !file.isFile()) {
        System.out.println("文件不存在");
    }
    System.out.println(file.length()+"bytes");

2.3.9 文件重命名

    File oldname = new File("res/text2.txt");
    File newname = new File("res/重名後的text2.txt");
    if(oldname.renameTo(newname)){
        System.out.println("重命名成功！");
    }else{
        System.out.println("重命名失敗！");
    }

2.3.10 設置文件為只讀/可寫

    File file = new File("res/text1.txt");
    //設置文件為只讀
    System.out.println("設置文件為只讀是否成功：" + file.setReadOnly());
    //判斷文件是否可以寫入
    System.out.println("文件是否可以寫入：" + file.canWrite());
    System.out.println("設置文件為可寫是否成功：" + file.setWritable(true));
    System.out.println("文件是否可以寫入：" + file.canWrite());

2.3.11 在指定目錄中創建文件

    File file = new File("d:/abc.txt");//操作c盤根目錄或者系統目錄時註意權限問題
    try {
        file.createNewFile();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

2.3.12 全文件名(包括路徑)比較

    File file1 = new File("res/text1.txt");
    File file2 = new File("res/重名後的text2.txt");
    if(file1.compareTo(file2) == 0) {
        System.out.println("文件路徑一致！");
    } else {
        System.out.println("文件路徑不一致！");
    }

2.3.13 復制文件

復制：復制的原理：其實就是將文件數據存儲到另一個文件中

1. 先創建一個文件，用於存儲復制的數據
2. 定義讀取流和要拷貝的文件進行關聯
3. 通過不斷的讀寫完成數據的存儲
4. 關閉資源

復制方法1:

    FileWriter fw = null;
    try {
        // 創建一個新的文件，用於復制的內容存儲
        fw = new FileWriter("res/copyOfText1.txt");
    } catch (IOException e) {
        e.printStackTrace();
    }
    FileReader fr;
    try {
        fr = new FileReader("res/text1.txt");
        int ch = 0;
        while ((ch = fr.read()) != -1) {
            fw.write(ch);
        }
        fw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

復制方法2：

    FileWriter fw = null;
    FileReader fr = null;
    try {
        // 寫入的目標文件
        fw = new FileWriter("res/copy2Oftext1.txt");
        // 讀取的目標文件
        fr = new FileReader("res/text1.txt");
        // 創建每次讀取的大小是1024字節
        char[] chr = new char[1024];
        int len = 0;
        while ((len = fr.read(chr)) != -1) {
            fw.write(chr, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fr != null) {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fw != null) {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.3.14 流的關閉

我們在關閉流的時候一定要在finally裏面，在關閉的時候要加判斷，判斷我們的文件是否存在，如果前面代碼拋出異常是不會運行後面的代碼，所以在關閉的時候要加上if判斷其是否為空，不為空則關閉。

finally{

    try {
        if(fw != null){
        fw.close();
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

練習：

讀取一個java文件，在控制臺輸出這個java文件

3. 流操作的總結

流操作的基本規律：

流對象有很多，我們不知道該用哪一個。我們通過下面三個明確來確定：

1. 明確源和目的

   源：輸入流 InputStream Reader
   目的：輸出流 OutputStream Writer
   

2. 操作的是否是純文本

   是：字符流
   不是：字節流
   

3. 當體系明確後，再明確要使用哪個具體對象

   通過設備來進行區分
   源設備：內存，硬盤，鍵盤
   目的設備：內存，硬盤，控制臺
   

4. 裝飾設計模式

3.1 裝飾設計模式概念

當想要對已有的對象進行功能增強時，可以定義類，將已有對象傳入，基於已有的功能，並提供加強功能，那麽自定義的該類就稱之為裝飾類。 裝飾類通常會通過構造方法接收被裝飾的對象。並基於被裝飾的對象的功能，提供更強的功能

public class Person {
    public void eat(){
        System.out.println("吃飯！");
}
}
class SuperPerson{
    private Person p;
    SuperPerson(Person p){
        this.p = p;
}
public void superEat(){
    System.out.println("開胃酒");
    p.eat();
    System.out.println("小吃、甜點");
}

3.2 裝飾和繼承有什麽區別？

裝飾設計模式：
當想要對已有的對象進行功能增強時，
可以定義類，將已有對象傳入，基於已有的功能，並提供加強功能。
那麽自定義的該類稱為裝飾類。

裝飾類通常會通過構造方法接收被裝飾的對象。
並基於被裝飾的對象的功能，提供更強的功能。

裝飾和繼承

MyReader//專門用於讀取數據的類。

|--MyTextReader
    |--MyBufferTextReader
|--MyMediaReader
    |--MyBufferMediaReader
|--MyDataReader
    |--MyBufferDataReader

·

class MyBufferReader
{
    MyBufferReader(MyTextReader text)
    {}
    MyBufferReader(MyMediaReader media)
    {}
}

上面這個類擴展性很差。

找到其參數的共同類型。通過多態的形式。可以提高擴展性。

class MyBufferReader extends MyReader
{
    private MyReader r;
    MyBufferReader(MyReader r)
    {}
}  

MyReader//專門用於讀取數據的類。

|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader//裝飾類

以前是通過繼承將每一個子類都具備緩沖功能。那麽繼承體系會復雜，並不利於擴展。

現在優化思想。單獨描述一下緩沖內容。將需要被緩沖的對象。傳遞進來。也就是，誰需要被緩沖，誰就作為參數傳遞給緩沖區。這樣繼承體系就變得很簡單。優化了體系結構。

裝飾模式比繼承要靈活。避免了繼承體系臃腫。而且降低了類於類之間的關系。

裝飾類因為增強已有對象，具備的功能和已有的是相同的，只不過提供了更強功能。所以裝飾類和被裝飾類通常是都屬於一個體系中的。

3.3 舉例

LineNumberReader:BufferedReader的裝飾類，在每一行前加上行號

    FileReader fr = null;
    LineNumberReader lnReader = null;
    try {
         fr = new FileReader("res/重名後的text2.txt");
         lnReader = new LineNumberReader(fr);
        String line = null;
        try {
            while((line = lnReader.readLine()) != null){
            System.out.println(lnReader.getLineNumber()+":"+line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }finally{
        try {
            lnReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

練習：

模擬LineNumberReader自定義一個實現類。功能有getLineNumber()和readLine()方法

5. 目錄的操作

public static void main(String[] args) {
    // 遞歸創建目錄
    String path = "D:\\a\\b\\c\\d\\e\\f\\g";
    addFile(path);
}

public static void addFile(String path) {
    File file = new File(path);
    // mkdir 創建單個目錄
    if (file.mkdirs()) { // 創建多個目錄
        System.out.println("目錄" + path + "創建成功");
    } else {
        System.out.println("目錄" + path + "創建失敗");
    }
}

1、獲取文件的目錄

file.getPath();

2、判斷一個文件是否為隱藏文件

 file.isHidden()返回boolean值

3、查看工作目錄

 String curDir = System.getProperty("user.dir");
 System.out.println(curDir);

4、獲取文件的上級目錄

file.getParent()  

5、判斷 file 是否是目錄

file.isDirectory()  

6、獲取目錄目錄下面的文件與文件夾

file.list()    

7、目錄 dir 必須要是空的，才能被刪除

file.delete()          

舉例： 獲取指定目錄下的所有目錄

    public static void main(String[] args) {
         printDirsStruct("d:\\a",1);
    }

    public static void printDirsStruct(String pathName,int index) {
        File f = new File(pathName);
        // 1 判斷是不是目錄
        if (f.isDirectory()) {
            for (int i = 0; i < index; i++) {
                System.out.print("-");
            }
            // 2 如果是目錄，打印自己
            System.out.println(f.getName());
            // 3 如果該目錄裏面還有子目錄，就要調用自己打印該子目錄。
            for (String str : f.list()) {
                String newPath = pathName + "/" + str;
                File f1 = new File(newPath);
                if (f1.isDirectory()) {
                    printDirsStruct(newPath, index + 1);
                }
            }
        }
    }

練習：

實現一個遞歸刪除目錄的方法

14. 流、文件和IO