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文件！

八、總結

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