Java知識點總結——IO流框架

IO框架

一、流的概念

概念：記憶體與儲存裝置之間傳輸資料的通道。

二、流的分類

按方向分類：

• 輸入流：將<儲存裝置>中的內容讀入到<記憶體>中
• 輸出流：將<記憶體>中的內容讀入到<儲存裝置>中

記憶體：記憶體是一種用於暫時存放[CPU]中的運算資料和外部儲存器交換資料的隨機儲存器。

儲存：一般可分為機械[硬碟]和[固態硬碟]，是一種儲存硬體，用於存放資料。

按單位進行劃分：

• 位元組流：以位元組為單位，可以讀寫所有資料。
• 字元流：以字元為單位，只能讀寫文字資料。

按功能進行劃分：

• 節點流：具有實際傳輸資料的讀寫功能。
• 過濾流：在節點流的基礎上增強功能，比如緩衝流。

三、位元組流

檔案位元組流

位元組流的兩個抽象父類：

• 位元組輸入流：InputStream

​ 這個抽象類是表示輸入位元組流的所有類的超類。

​ 常用方法：

• 位元組輸出流：OutputStream

​ 這個抽象類是表示位元組輸出流的所有類的超類。 輸出流接收輸出位元組並將其傳送到某個接收器。

​ 常用方法：

位元組流的兩個子類——檔案位元組流：

• 檔案位元組輸入流：FileInputStream——讀取檔案

public class FileInputStream extends InputStream

​ 從檔案系統中的檔案獲取輸入位元組。 什麼檔案可用取決於主機環境。

​ FileInputStream用於讀取諸如影像資料的原始位元組流。 要閱讀字串，請考慮使用FileReader 。

構造方法：

常用方法：

public int read(byte[] b)
從流中讀取多個位元組，將讀到的內容存入b陣列，返回實際讀到的位元組數；如果達到檔案的尾部，則返回-1

第一種讀取方式：單個位元組讀取——效率不高！

【參考程式碼】

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

public class InputStreamTest {
    public static void main(String[] args) throws Exception {
//        1.建立FileInputStream，並指定檔案路徑
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
//        2.讀取檔案fis.read()：一個一個的讀
        int data = 0;
        while ((data = fis.read()) != -1){
            System.out.println();
        }
//        3.讀完之後，關閉流
        fis.close();
    }

}

第二種讀取方式：一次讀取多個位元組，多一個位元組陣列！

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

public class InputStreamTest {
    public static void main(String[] args) throws Exception {
//        1.建立FileInputStream，並指定檔案路徑
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
//        2.讀取檔案fis.read()：一個一個的讀
//        int data = 0;
//        while ((data = fis.read()) != -1){
//            System.out.println();
//        }
//        2.1一次讀取多個位元組
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = fis.read(buf)) != -1){
            System.out.println(new String(buf, 0, count)); // abcdefg
        }
//        3.讀完之後，關閉流
        fis.close();
    }

}

• 檔案位元組輸出流：FileOutputStream——寫入檔案

public class FilterOutputStream extends OutputStream

這個類是過濾輸出流的所有類的超類。 這些流位於已經存在的輸出流（ 底層輸出流） 之上 ，它使用它作為資料的基本接收器，但是可能沿著資料方向轉換或提供附加功能。

構造方法：

常用方法：

public int write(byte[] b)
一次寫多個位元組，將b陣列中的所有位元組，寫入輸出流中！

【參考程式碼】

import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class FileOutPutStreamTest {
    public static void main(String[] args) throws Exception {
        // 建立檔案輸出流
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true); // 加true後新的位元組不會覆蓋原位元組
        // 讀入多個位元組
        String str = "abcdef";
        fos.write(str.getBytes());
        // 關閉流
        fos.close();
        System.out.println("載入完畢！");

    }
}

注：如果是文字檔案最好用字元流

案例：使用檔案位元組流進行檔案複製

複製檔案：利用檔案位元組流，一邊讀取，一邊寫入！

注：使用位元組流可以複製任意檔案，而字元流卻不行！

【參考程式碼】

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileCopyDemon {
    public static void main(String[] args) throws Exception{
        // 建立檔案輸入流
        FileInputStream fis = new FileInputStream("d:\\bbb.txt");

        // 建立檔案輸出流
        FileOutputStream fos = new FileOutputStream("d:\\ccc.txt");

        //複製檔案：一邊讀取，一邊寫入
        byte[] buf = new byte[1024];
        int count = 0;// count實際讀取的個數
        while ((count = fis.read(buf)) != -1){
            fos.write(buf, 0, count);
        }
        fis.close();
        fos.close();
        System.out.println("複製完畢！");
    }
}

檔案位元組緩衝流

緩衝流：BufferedInputStream/BufferedOutputStream。提高IO效率，減少訪問磁碟的次數；資料儲存在緩衝區，flush是將緩衝區的內容寫入檔案中，也可以直接close。

• 位元組輸入緩衝流：BufferedInputStream——快速讀取檔案

​ BufferedInputStream為另一個輸入流新增了功能，即緩衝輸入和支援mark和reset方法的功能。 當建立BufferedInputStream時，將建立一個內部緩衝區陣列。 當從流中讀取或跳過位元組時，內部緩衝區將根據需要從所包含的輸入流中重新填充，一次有多個位元組。 mark操作會記住輸入流中的一點，並且reset操作會導致從最近的mark操作之後讀取的所有位元組在從包含的輸入流中取出新的位元組之前重新讀取。

構造方法：

常用方法：

【參考程式碼】

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class BufferedInputStreamDemon {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //1. 建立位元組緩衝輸入流
        BufferedInputStream bis = new BufferedInputStream(fis); // 維護位元組流，從緩衝區讀取位元組，加快效率

        //2. 讀取
        int data = 0;
        while((data = bis.read()) != -1){
            System.out.println((char) data);
        }

        //3. 關閉緩衝流
        bis.close();
    }
}

• 位元組輸出緩衝流：BufferedOutputStream——快速寫入檔案

​ 該類實現緩衝輸出流。 通過設定這樣的輸出流，應用程式可以向底層輸出流寫入位元組，不必為寫入的每個位元組導致底層系統的呼叫。

構造方法：

常用方法：

【參考程式碼】

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class BufferedOutputStreamDemon {
    public static void main(String[] args) throws Exception{

        FileOutputStream fos = new FileOutputStream("d:\\buff.txt");
        //1. 建立輸出緩衝流
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2. 寫入檔案
        String str = "hello";
        for(int i = 0; i <= 5; i ++){
            bos.write(str.getBytes()); // 寫入8k緩衝區
            bos.flush(); // 重新整理到硬碟
        }
        //3. 關閉流(內部呼叫)
        fos.close(flush方法);
    }
}

四、編碼方式

注：當編碼方式和解碼方式不一致時，就會出現亂碼！

五、字元流

引入：3個位元組相當於一個字元，當我們要讀取漢字（字元）時，如果用位元組流來讀取的話，他是一個一個位元組讀取的，最終的結果是位元組，而不是我們想要的字元了！

字元流的兩個父類（抽象類）：

• Reader：字元輸入流

  常用方法：

  public int read() {}
  public int read(char[] c) {}
  public int read(char[] b, int off, int len) {}
  

• Write：字元輸出流

  常用方法：

  public void write(int n) {}
  public void write(String str) {}
  public void write(char[] c) {}
  

檔案字元流

• FileReader——檔案字元輸入流

閱讀字元檔案的便利課。 該類的建構函式假定預設字元編碼和預設位元組緩衝區大小是適當的。 要自己指定這些值，請在FileInputStream上構造一個InputStreamReader。

FileReader是用於讀取字元流。 要讀取原始位元組流，請考慮使用FileInputStream 。

public class FileReader	extends InputStreamReader

構造方法：

常用方法：繼承父類！

public int read(char[] c);
從流中讀取多個字元，講讀到內容存入c陣列，返回實際讀到的字元數；如果檔案達到尾部，則返回-1.

【參考程式碼】

import java.io.FileReader;

public class FileReaderDemon {
    public static void main(String[] args) throws Exception{

        //1. 建立FileReader 檔案字元輸入流
        FileReader fr = new FileReader("d:\\hello.txt");

        //2. 讀取
        //2.1 單個讀取
//        int data = 0;
//        while ((data = fr.read()) != -1){ // 讀取一個字元！
//            System.out.println((char)data);
//        }
        char[] buf = new char[1024];
        int count = 0;
        while((count = fr.read(buf)) != -1){
            System.out.println(new String(buf, 0, count));
        }
        //3. 關閉
        fr.close();
    }
}

• FileWriter——檔案字元輸出流

public void write(String str);
一次寫入多個字元，將b陣列中所有字元，寫入輸出流；

【參考程式碼】

import java.io.FileWriter;

public class FileWriterDemon {
    public static void main(String[] args) throws Exception{

        //1. 建立FileWriter物件
        FileWriter fw = new FileWriter("d:\\write.txt");

        //2. 寫入字元
        String str = "防不勝防";
        for(int i = 0; i < str.length(); i ++){
            fw.write(str);
            fw.flush();
        }
        //3. 關閉
        fw.close();
        System.out.println("執行完畢");
    }
}

案例：檔案字元流實現文字檔案複製

注：FileReader、FileWriter只能複製文字檔案，不能複製圖片或者二進位制檔案！—— 文字檔案有字元編碼！

【參考程式碼】

import java.io.FileReader;
import java.io.FileWriter;

public class CopyDemon {
    public static void main(String[] args) throws Exception{

        //1. 建立FileReader  FileWriter 物件
        FileReader fr = new FileReader("d:\\write.txt");
        FileWriter fw = new FileWriter("d:\\write2.txt");

        //2. 讀寫
        int data = 0;
        while((data = fr.read()) != -1){
            fw.write(data);
            fw.flush();
        }
        
        //3. 關閉
        fr.close();
        fw.close();
        System.out.println("複製完畢！");

    }
}

字元緩衝流

字元緩衝流：BufferedReader/BufferedWriter

（1）高效讀寫

（2）支援輸入換行

（3）可一次寫一行，讀一行。

• BufferedReader——字元緩衝輸入流

​ 從字元輸入流讀取文字，緩衝字元，以提供字元，陣列和行的高效讀取。

​ 可以指定緩衝區大小，或者可以使用預設大小。 預設值足夠大，可用於大多數用途。

​ 通常，由讀取器做出的每個讀取請求將引起對底層字元或位元組流的相應讀取請求。 因此，建議將BufferedReader包裝在其read（）操 作可能昂貴的讀取器上，例如FileReader

  BufferedReader in = new BufferedReader(new FileReader("foo.in")); 

將緩衝指定檔案的輸入。 沒有緩衝，每次呼叫read（）或readLine（）可能會導致從檔案中讀取位元組，轉換成字元，然後返回，這可能非常低效。

構造方法：

常用方法：

【參考程式碼】

```
import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 字元緩衝流讀取檔案
 */
public class BufferedReaderDemon {
    public static void main(String[] args) throws Exception{

        //1. 建立緩衝流
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader br = new BufferedReader(fr);

        //2. 讀取
        //2.1 第一種讀取方式
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count = br.read(buf)) != -1){
//            System.out.println(new String(buf, 0, count));
//        }
        //2.2 第二種讀取方式。 一行一行的讀取
        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        //3. 關閉
        br.close();
    }
}

• BufferedWriter——字元緩衝輸出流（寫入字元）

將文字寫入字元輸出流，緩衝字元，以提供單個字元，陣列和字串的高效寫入。

可以指定緩衝區大小，或者可以接受預設大小。 預設值足夠大，可用於大多數用途。

提供了一個newLine（）方法，它使用平臺自己的系統屬性line.separator定義的行分隔符概念。 並非所有平臺都使用換行符（'\ n'）來終止行。 因此，呼叫此方法來終止每個輸出行，因此優選直接寫入換行符。

構造方法：

常用方法：

【參考程式碼】

import java.io.BufferedWriter;
import java.io.FileWriter;

public class BufferedWriterDemon {
    public static void main(String[] args) throws Exception{
        //1. 建立BufferedWriter物件
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2. 寫入
        for (int i = 0; i < 5; i ++){
            bw.write("好好學習吧！");
            bw.newLine();// 換行！
            bw.flush();
        }
        //3. 關閉
        bw.close();
    }
}

列印流

• PrintWriter——列印流

將物件的格式表示列印到文字輸出流。 這個類實現了全部在發現print種方法PrintStream 。 它不包含用於編寫原始位元組的方法，程式應使用未編碼的位元組流。

不像類，如果啟用自動重新整理，它只會在呼叫的println，printf，或format方法來完成，而不是當一個換行符恰好是輸出。 這些方法使用平臺自己的行分隔符而不是換行符。

轉換流

轉換流：InputStreamReader/OutputStreamWriter

（1）可以將位元組流轉為字元流

（2）可設定字元的編碼方式

轉換流的使用：

InputStreamReader讀取檔案

【參考程式碼】

import java.io.FileInputStream;
import java.io.InputStreamReader;

public class ZhuanHuanLiuTest {
    public static void main(String[] args) throws Exception{
        //1. 建立InputStreamReader物件
        FileInputStream fis = new FileInputStream("d:\\write.txt");
        InputStreamReader isr = new InputStreamReader(fis, "utf-8"); // 轉換流設定編碼方式

        //2.讀取檔案
        int data = 0;
        while ((data = isr.read()) != -1){
            System.out.println((char) data);
        }
        //3. 關閉
        isr.close();
    }
}

OutputStreamWriter——寫入檔案

【參考程式碼】

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class ZhuanHuanLiuTest {
    public static void main(String[] args) throws Exception{
        //1. 建立OutputStreamWriter物件
        FileOutputStream  fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk"); // 轉換流設定編碼方式

        //2. 寫入
        for(int i = 0; i < 5; i ++){
            osw.write("我愛學習\r\n");
            osw.flush();
        }
        //3. 關閉
        osw.close();
    }
}

六、物件流

物件流：ObjectInputStream/ObjectOutputStream。

（1）增強了緩衝區功能

（2）增強了讀取8種基本資料型別和字串功能

（3）增強了讀寫物件的功能：

​ readObject() 從流中讀取一個物件（反序列化）

​ writeObject(Object obj) 向流中寫入一個物件（序列化）

使用流傳輸物件的過程稱為序列化，和反序列化。

• 物件輸出流：ObjectOutputStream——序列化（寫入物件）

​ ObjectOutputStream將Java物件的原始資料型別和圖形寫入OutputStream。 可以使用ObjectInputStream讀取（重構）物件。 可以 通過使用流的檔案來實現物件的持久儲存。 如果流是網路套接字流，則可以在另一個主機上或另一個程式中重構物件。

構造方法：

常用方法：

【參考程式碼】

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class ObjectOutputStreamDemon {
    /**
     * 使用ObjectOutputStream實現物件的序列化————讀入物件
     * 要求：序列化類必須實現介面
     */
    public static void main(String[] args) throws Exception{

        //1. 建立物件流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //2. 序列化（寫入操作）
        Student student = new Student("張三",19);
        oos.writeObject(student);

        //3. 關閉(自帶flush()方法了)
        oos.close();
        System.out.println("序列化完畢");

    }
}

class  Student implements Serializable {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

使用ObjectOutputStream實現物件的序列化————寫入物件

​ 要求：序列化類必須實現介面

• 物件輸入流：ObjectInputStream——反序列化（讀取重構成物件）

​ ObjectInputStream反序列化先前使用ObjectOutputStream編寫的原始資料和物件。

構造方法：

常用方法：

【參考程式碼】

import java.io.*;


public class ObjectInputStreamDemon {
    public static void main(String[] args) throws Exception{
        //1. 建立物件流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);

        //2. 讀取檔案（反序列化）
        Student st = (Student) ois.readObject();

        //3. 關閉
        ois.close();

        System.out.println(st.toString());// Student{name='張三', age=19}
    }


}

序列化和反序列化注意事項：

（1）序列化類必須實現Serializable介面

（2）序列化類中物件屬性要求實現Serializable介面

（3）序列化版本號ID，保證序列化的類和反序列化的類是同一個類

（4）使用transient（瞬間的）修飾屬性，這個屬性不能序列化

（5）靜態屬性不能序列化

（6）序列化多個物件，可以藉助集合

七、File類

概念：代表物理磁碟中的一個檔案或者資料夾（目錄）。

常用方法：

檔案操作

（1）分隔符：

• 路徑分隔符;
• 名稱分隔符\

（2）檔案操作：

• 建立檔案createNewFile()

  boolean createNewFile()當且僅當具有該名稱的檔案尚不存在時，原子地建立一個由該抽象路徑名命名的新的空檔案。

  if(!file.exists()){ // 如果檔案不存在則建立
      boolean b = file.createNewFile();
      System.out.println("建立結果" + b);
  }
  

• 刪除檔案

  直接刪除：delete()

  boolean delete()刪除由此抽象路徑名錶示的檔案或目錄

  JVM退出時刪除：

  file.deleteOnExit();
  Thread.sleep(5000); // 休眠五秒
  

• 獲取檔案資訊

  • getAbsolutePath()：獲取到檔案的絕對路徑

  • getPath()：獲取到檔案的路徑

  • getName()：獲取檔案的名稱

  • getParent()：獲取檔案的父級目錄

  • length()：獲取檔案的長度

  • lastModified()：獲取檔案的建立時間

    System.out.println("檔案建立時間：" + new Date(file.lastModified()));
    

• 判斷

  • canWrite()：判斷檔案是否可寫
  • isFile()：判斷是否是檔案
  • isHidden()：判斷檔案是否隱藏

【參考程式碼】

import java.io.File;
import java.util.Date;

public class FileTest {
    public static void main(String[] args) throws Exception{
        fileOpe();
    }

    /**
     * 檔案操作
     */
    public static void fileOpe() throws Exception{
        //1. 建立檔案
        File file = new File("d:\\file.txt"); // 只是建立了一個檔案物件，此時在d盤下並沒有該檔案
        if(!file.exists()){ // 如果檔案不存在則建立
            boolean b = file.createNewFile();
            System.out.println("建立結果" + b);
        }
        //2. 刪除檔案
        //2.1 直接刪除
//        System.out.println("刪除結果" + file.delete());
//        //2.2 JVM退出時刪除
//        file.deleteOnExit();
//        Thread.sleep(5000); // 休眠五秒

        //3. 獲取檔案資訊
        System.out.println("獲取檔案絕對路徑" + file.getAbsolutePath()); // 獲取檔案絕對路徑d:\file.txt
        System.out.println("獲取路徑" + file.getPath());
        System.out.println("獲取檔名稱" + file.getName());
        System.out.println("獲取檔案父目錄" + file.getParent());
        System.out.println("獲取檔案長度" + file.length());
        System.out.println("檔案建立時間：" + new Date(file.lastModified()));

        //4. 判斷
        System.out.println("是否可寫" + file.canWrite());
        System.out.println("是否是檔案" + file.isFile());
        System.out.println("是否隱藏" + file.isHidden());

    }
}

資料夾操作

• 建立資料夾

  boolean	mkdir()建立由此抽象路徑名命名的目錄。
  boolean	mkdirs()建立由此抽象路徑名命名的目錄，包括任何必需但不存在的父目錄。

          File dir = new File("d:\\aaa\\bbb\\ccc");
          if(! dir.exists()){
              dir.mkdir();// 只能單級目錄
              System.out.println("建立結果：" +  dir.mkdirs()); //mkdirs();//可以建立多級目錄
          }
  

• 刪除資料夾

  直接刪除：delete()——只能刪除空目錄

  JVM刪除：file.deleteOnExit();Thread.sleep(5000); // 休眠五秒

• 獲取資料夾資訊

  • getAbsolutePath()：獲取到資料夾的絕對路徑
  • getPath()：獲取到資料夾的路徑
  • getName()：獲取資料夾的名稱（最裡層）
  • getParent()：獲取資料夾的父級目錄
  • lastModified()：獲取檔案的建立時間

• 判斷

  • isDirectory()：判斷是否是資料夾
  • isHidden()：判斷檔案是否隱藏

• 遍歷檔案

  (1)list()

  String[]	list()返回一個字串陣列，命名由此抽象路徑名錶示的目錄中的檔案和目錄。

         //5. 遍歷資料夾
          File dir2 = new File("e:\\picture");
          String[] files = dir2.list();
          for(String str: files){
              System.out.println(str);
          }
  

  (2) listFiles()

  File[]	listFiles()返回一個抽象路徑名陣列，表示由該抽象路徑名錶示的目錄中的檔案。

      //5. 遍歷資料夾
       File dir2 = new File("e:\\picture");
       File[] files = dir2.listFiles(); // 檔案陣列
       for(File file: files){
           System.out.println(file.getName());
       }
  

FileFilter介面

當呼叫File類中的listFiles()方法時，支援傳入FileFilter介面介面實現類，對獲取檔案進行過濾，只有滿足條件的檔案才可以出現在listFiles()方法的返回值中。

File[]	listFiles(FileFilter filter)返回一個抽象路徑名陣列，表示由此抽象路徑名錶示的滿足指定過濾器的目錄中的檔案和目錄。

【參考程式碼】

		File dir2 = new File("e:\\picture");
		// 過濾：過濾出滿足條件的檔案
        File[] file2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".png")){ // 只要.png結尾的圖片
                    return true;
                }
                return false;
            }
        });
        // 遍歷輸出
        for(File file : file2){
            System.out.println(file.getName());
        }

遞迴遍歷與刪除

遞迴遍歷資料夾：

遍歷拿到dir.listFiles()路徑的路徑陣列，陣列不為空且有檔案的情況下，如果是資料夾遞迴則進去，直到不是資料夾，然後輸出檔案，否則輸出當前目錄下的檔案！

【參考程式碼】

import java.io.File;

public class ListDemon {
    public static void main(String[] args) {
        listDir(new File("e:\\aaa"));
    }
    //遞迴遍歷資料夾
    public static void listDir(File dir){
        File[] files = dir.listFiles();// 得到所有得子檔案與子資料夾
        System.out.println("路徑："+ dir.getAbsolutePath());
        if(files != null && files.length > 0){
            for(File file : files){
                if(file.isDirectory()){// 判斷是否為資料夾
                    listDir(file); // 如果是資料夾遞迴進去，直到不是資料夾
                }else{// 不是資料夾 則輸出
                    System.out.println(file.getAbsolutePath());
                }
            }
        }

    }
}

我電腦E盤下的aaa檔案如下圖：

遞迴刪除資料夾:

我們直到delete()方法只能刪除空目錄。如果目錄裡邊有內容，delete()方法是無法刪除的，即我們想用delete()方法刪除上述aaa檔案是行不通的！

為此，我們得先將aaa檔案中所有內容給刪除之後，才能將aaa檔案刪除掉！aaa裡邊有bbb資料夾，為此得先把它裡邊得內容先刪掉，bbb裡邊有ccc資料夾為此得先把它裡邊得內容先刪掉........然後再逐步回退刪除資料夾！

【參考程式碼】

import java.io.File;

public class ListDemon {
    public static void main(String[] args) {
        deleteDir(new File("e:\\aaa"));
    }

    // 遞迴刪除資料夾
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if(files != null && files.length > 0){
            for(File file : files){
                if(file.isDirectory()){
                    deleteDir(file); // 遞迴
                }else {
                    // 刪除檔案
                    System.out.println(file.getAbsolutePath() + "刪除：" + file.delete());
                }
            }
        }
        // 刪除資料夾
        System.out.println(dir.getAbsolutePath() + "刪除：" + dir.delete());
    }

}

圖示：

Properties

Properties：屬性集合

public class Properties extends Hashtable<Object,Object>

Properties類表示一組持久的屬性。 Properties可以儲存到流中或從流中載入。 屬性列表中的每個鍵及其對應的值都是一個字串。

屬性列表可以包含另一個屬性列表作為其“預設值”; 如果在原始屬性列表中找不到屬性鍵，則會搜尋此第二個屬性列表。

特點：

• 儲存屬性名和屬性值
• 屬性名和屬性值都是字串型別
• 沒有泛型
• 和流有關

String	getProperty(String key)使用此屬性列表中指定的鍵搜尋屬性，得到對應得value。
Object	setProperty(String key, String value)同 Hashtable方法 put 。
void	list(PrintStream out)將此屬性列表列印到指定的輸出流。
void	load(InputStream inStream)從輸入位元組流讀取屬性列表（鍵和元素對）。
void	store(OutputStream out, String comments)將此屬性列表（鍵和元素對）寫入此 Properties表中，以適合於使用方法載入到 Properties表中的格式輸出流。

後面學習的JDBC連線資料會用得到.properties檔案！

八、總結

注：如果文章有任何錯誤或不足，請各位大佬盡情指出，評論留言留下您寶貴的建議！如果這篇文章對你有些許幫助，希望可愛親切的您點個贊推薦一手，非常感謝啦