凱哥帶你從零學大數據系列之Java篇---第二十六章:IO流詳解

課程大綱:

• IO流的簡介
• 基礎的IO流(重點)
• 常見的其他流

http://1.IO流的簡介

1.1. 什麼是IO流

IO流： Input/Output Stream

流: 指的是一串流動的數據， 在數據在流中按照指定的方向進行流動。 實現數據的讀取、寫入的功能。

1.2. IO流的使用場景

使用File類， 只能做關於文件的操作， 獲取屬性、 創建文件、 刪除文件、 移動文件等操作， 但是不包含讀取文件中的內容。 如果需要讀取、修改文件中的內容， 此時就需要使用IO流來完成了。

使用場景: 對某一個文件進行讀取或者寫入操作。

注意事項:
IO流是對一個文件進行讀寫的， 不是一個文件夾！ 在使用IO流的時候， 不要建立與一個文件夾的連接。

1.3. IO流的分類

按照不同的分類標準， 能夠得到不同分類的IO流：

• 按照流中流動的數據單位：
  • 字節流： 流中流動的數據， 是以字節爲單位的。
  • 字符流: 流中流動的數據， 是以字符爲單位的。

 

• 按照流中數據流動的方向：
  • 輸入流： 數據從文件流動到程序中。
  • 輸出流： 數據從程序流動到文件中。

2.基礎的IO流

2.1. 基礎的IO流類的簡介

其實在 http://java.io 包中， 有很多很多的類， 都是來描述IO流的。 但是基本上所有的IO流的類， 都是直接或間接的繼承自四大父類流。

• 字節輸入流: InputStream
• 字節輸出流: OutputStream
• 字符輸入流： Reader
• 字符輸出流: Writer

2.2. IO流使用的注意事項

• 四大父類流， 都是抽象類， 都不能實例化對象。 因此， 需要藉助他們的子類實現數據的讀寫。
• 流對象一旦實例化完成， 將建立一個程序與文件之間的連接。 這個連接會持有這個文件。 如果這個連接不斷， 此時這個文件就是一個被使用中的狀態， 此時將無法對這個文件進行其他的操作， 例如刪除。
• 一個流在使用完成之後， 切記！ 一定要進行流的關閉。

2.3. 建立程序與文件的連接

其實， 就是建立了程序與文件之間連接的管道， 實現數據在這個管道之內進行流動。 管道分爲不同的類型： 字節輸入流、 字節輸出流、 字符輸入流、 字符輸出流。 下面以字節輸入流 InputStream 爲例。

2.3.1. 標準流程

• try結構外面， 聲明流對象， 爲了在finally中使用。
• 在try結構裏面， 實例化流對象， 並捕獲異常。
• 在finally結構中， 對流進行關閉。 在關閉的時候， 需要考慮流對象是否是null， 以及要處理 IOException 異常。

import java.io.*;

/**
 * @Description 測試文件與程序的連接建立
 */
public class IO1 {
    public static void main(String[] args) {
        // 在外面聲明變量
        InputStream inputStream = null;
        try {
            // 實例化一個FileInputStream對象，向上轉型爲InputStream類型類型。
            // 這個實例化如果完成，將會建立程序與文件之間的連接。
            // 建立好之後，數據就可以從文件中流動到程序中。
            // 注意: 數據流動到程序中，並不意味着文件中沒有數據了！
            // 這個過程中，會出現 FileNotFoundException 的異常，原因: 路徑寫錯了，這個路徑上沒有文件
            inputStream = new FileInputStream("file\\day25\\source");
            // 數據的讀取操作
            // 在數據讀取的過程中，也會出現 IOException 異常。一旦出現異常，後序的代碼都不執行了，直接執行catch語句了
            // 流的關閉，不能放到try裏面。需要放到finally中。
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            // 流在使用結束之後，一定要進行關閉。
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.3.2. try結構的特使使用

在 JDK1.7 之後， 可以在try後面添加一對小括號。 將 AutoClosable 接口實現類的對象， 實例化放到小括號中完成。 此時， 在try結構執行結束的時候， 會自動的調用AutoClosable接口實現類中的close方法， 進行流的關閉。 這樣寫的流的建立比較簡單， 也是後面我們最主要使用的方式。

import java.io.*;

/**
 * @Description 常見的IO流的創建的方式
 */
public class IO2 {
    public static void main(String[] args) {
        /**
         * try結構的特殊語法: try ()
         * 將 AutoClosable 接口的實現類對象的實例化放到小括號中。
         * 此時，在離開了try結構的時候，會自動的對這個類進行close方法的調用
         */
        try (InputStream inputStream = new FileInputStream("file\\day25\\source")) {
		// 數據的讀取操作
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(new File("file\\day25\\source").delete());
    }
}

2.4. InputStream

2.4.1. InputStream簡介

這是一個字節輸入流。 從方向來說， 是一個輸入流， 數據是從文件中流動到程序中， 是爲了讀取文件中的數據的。 從數據單位來說， 這個流中流動的數據是以字節爲單位的。

2.4.2. 文件的讀取

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

/**
 * @Description 使用字節流進行數據的讀取
 */
public class InputStreamTest {
    public static void main(String[] args) {
        // 1. 建立程序與文件之間的連接，用來讀取這個文件
        try (InputStream inputStream = new FileInputStream("file\\day25\\source")) {
            // 2. 讀取字節流中的數據，需要有一個字節數組，用來讀取數據
            //    這個數組長度，不用和文件一樣大小，找一個大小合適的數組讀取即可
            byte[] array = new byte[32];
            // 3. 聲明一個整型變量，用來記錄每次讀取了多少個字節的數據
            int length = 0;
            // 3. 循環讀取數據
            while ((length = inputStream.read(array)) != -1) {
                // 將讀取到的字節數組中的數據，轉成字符串輸出
                // 爲了去除最後一次進行讀取數據的時候，上次讀取殘留的問題
                // 最後一次讀取的數據，只有指定部分是我們需要的數據
                String str = new String(array, 0, length);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.5. OutputStream

2.5.1. OutputStream簡介

字節輸出流。 從方向上來分， 是一個輸出流， 數據從程序中流動到文件中， 實現文件的寫操作。 從流中流動的數據單位來分， 是一個字節流， 流中流動的數據是以字節爲單位的。

2.5.2. 文件的寫

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

/**
 * @Description 字節輸出流，寫文件
 */
public class OutputStreamTest {
    public static void main(String[] args) {
        // 1. 實例化一個管道，連接文件和程序。
        //    對於FileOutputStream來說，如果目標文件不存在，則會自動的創建。
        //    當無法創建這個文件的時候(父級目錄不存在)，創建會失敗，會觸發 FileNotFoundException 。
        try (OutputStream outputStream = new FileOutputStream("file\\day25\\dst", true)) {
            // 2. 準備需要寫入到這個文件中的數據
            String message = "你好，師姐";
            // 3. 將數據寫入到輸出流中，由輸出流寫入到文件中
            outputStream.write(message.getBytes());

            // 沖刷緩衝區，將緩衝區中的數據強制流動到文件中。
            // 在流關閉的時候，會自動的調用。
            outputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
​

2.6. 案例: 文件拷貝

2.6.1. 需求分析

實現， 將一個文件拷貝到另外一個地方。 注意， 這個不是剪切， 拷貝完成之後， 原文件還在。

實現方式： 藉助兩個流來完成。

• 使用字節流輸入， 循環讀取原文件中的數據。
• 使用字節輸出流， 將每次讀取到的數據， 寫入到目標文件中。

2.6.2. 示例代碼

import java.io.*;

/**
 * @Description 使用字節流實現文件的拷貝
 */
public class FileCopy {
    public static void main(String[] args) {
        boolean ret = copy("C:\\Users\\luds\\Desktop\\src.mp4", "C:\\Users\\luds\\Desktop\\dst.mp4");
        System.out.println(ret);
    }

    /**
     * 實現功能: 將源文件中的數據拷貝到目標文件
     * @param srcPath 原文件路徑
     * @param dstPath 目標文件路徑
     * @return 拷貝的結果
     */
    private static boolean copy(String srcPath, String dstPath) {
        // 1. 判斷目標路徑上，是否有文件存在
        File dst = new File(dstPath);
        if (dst.exists()) {
            return false;
        }
        // 2. 實現文件的拷貝
        try (InputStream inputStream = new FileInputStream(srcPath);
             OutputStream outputStream = new FileOutputStream(dst)) {
            // 拷貝的過程
            // 2.1. 實例化一個字節數組
            byte[] array = new byte[1024];
            // 2.2. 聲明一個整型變量，用來記錄每次讀取到了多少個字節的數據
            int length = 0;
            // 2.3. 循環讀取數據
            while ((length = inputStream.read(array)) != -1) {
                // 2.4. 將讀取到的數據，寫入到輸出流中
                outputStream.write(array, 0, length);
            }
            // 2.5. 沖刷緩衝區
            outputStream.flush();
            return true;
        }
        catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }
}

2.7. Reader

2.7.1. Reader的簡介

這是一個字符輸入流。 從方向來說， 是一個輸入流， 數據是從文件中流動到程序中， 是爲了讀取文件中的數據的。 從數據單位來說， 這個流中流動的數據是以字符爲單位的。

2.7.2. 讀取文件

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 * @Description 字符輸入流讀取數據
 */
public class ReaderTest {
    public static void main(String[] args) {
        // 讀取過程與字節輸入流完全相同，只需要將使用到的類換一下即可。
        try (Reader reader = new FileReader("file\\day25\\src")) {
            // 1. 實例化一個字符數組
            char[] array = new char[100];
            // 2. 聲明一個變量，用來記錄每次讀取到了多少個數據
            int length = 0;
            // 3. 循環讀取數據
            while ((length = reader.read(array)) != -1) {
                String str = new String(array, 0, length);
                System.out.print(str);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.8. Writer

2.8.1. Writer的簡介

字符輸出流。 從方向上來分， 是一個輸出流， 數據從程序中流動到文件中， 實現文件的寫操作。 從流中流動的數據單位來分， 是一個字符流， 流中流動的數據是以字符爲單位的。

2.8.2. 文件的寫操作

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * @Description 使用字符流寫數據
 */
public class WriterTest {
    public static void main(String[] args) {
        // 1. 實例化相關的類
        try (Writer writer = new FileWriter("file\\day25\\target", true)) {
            // 2. 將數據寫入到輸出流中
            writer.write("hello, world");
            // 3. 沖刷緩衝區
            writer.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

2.9. 案例: 文件拷貝

2.9.1. 需求分析

實現， 將一個文件拷貝到另外一個地方。 注意， 這個不是剪切， 拷貝完成之後， 原文件還在。

實現方式： 藉助兩個流來完成。

• 使用字符輸入流， 循環讀取原文件中的數據。
• 使用字符輸出流， 將每次讀取到的數據， 寫入到目標文件中。

2.9.2. 示例代碼

/**
  * 使用字符流實現文件的拷貝
  * @param srcPath 原文件路徑
  * @param dstPath 目標文件路徑
  */
private static void fileCopy2(String srcPath, String dstPath) {
    // 2. 循環讀取目標文件中的數據
    try (Reader reader = new FileReader(srcPath); Writer writer = new FileWriter(dstPath)) {
        // 3. 循環讀取源文件中的數據
        char[] array = new char[100];
        int length = 0;
        while ((length = reader.read(array)) != -1) {
            // 4. 將讀取到的數據寫入到輸出流
            writer.write(array, 0, length);
        }
        writer.flush();
        return true;
    }
    catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

3. 常見的其他流

3.1. 緩衝流

3.1.1. 緩衝流的簡介

給普通的IO流， 套上一個緩衝區。 所有的使用緩衝流進行的讀寫操作， 都是和緩衝區進行交互的， 避免了頻繁的IO操作。 這樣一來， 帶來的好處就是可以提高讀寫的效率。 這個緩衝區， 其實是一個數組。

常見的緩衝流:

• BufferedInputStream : 緩衝字節輸入流
• BufferedOutputStream ： 緩衝字節輸出流
• BufferedReader ： 緩衝字符輸入流
• BufferedWriter ： 緩衝字符輸出

3.1.2. 緩衝字節流

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

/**
 * @Description BufferedInputStream使用
 */
public class BufferedInputStreamTest {
    public static void main(String[] args) {
        // 過程和InputStream一模一樣的
        // 緩衝字節輸入流流是需要基於一個字節輸入流來進行實例化的
        // 在這裏，BufferedInputStream構造方法中的InputStream對象，只是用來做當前的對象的實例化，在使用結束的時候，理論上來講，是需要關閉的
        // 實際在使用中，使用結束後，只需要關閉BufferedInputStream即可。
        try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\day26\\source"))) {
            // 1. 實例化一個字節數組
            byte[] array = new byte[1024];
            // 2. 聲明一個整型變量，用來記錄每次讀取了多少個字節數據
            int length = 0;
            // 3. 循環讀取
            while ((length = bufferedInputStream.read(array)) != -1) {
                // 4. 將讀取到的數據轉成字符串輸出到控制檯
                String msg = new String(array, 0, length);
                System.out.println(msg);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

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

/*
 * @Description BufferedOutputStream
 */
public class BufferedOutputStreamTest {
    public static void main(String[] args) {
        // 1. 實例化一個緩衝字節輸出流對象
        try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("file\\day26\\target")))  {
            // 2. 將數據寫入到輸出流中
            bufferedOutputStream.write("hello world".getBytes());
            bufferedOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.1.3. 緩衝字符流

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * @Description
 */
public class BufferedReaderTest {
    public static void main(String[] args) {
        // 藉助一個字符流，實例化一個緩衝字符輸入流
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("file\\day26\\src"))) {
            // 從流中讀取數據
            char[] array = new char[100];
            int length = 0;
            while ((length = bufferedReader.read(array)) != -1) {
                System.out.print(new String(array, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

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

/**
 * @Description
 */
public class BufferedWriterTest {
    public static void main(String[] args) {
        // 藉助一個字符輸出流，實例化一個緩衝字符輸出流對象
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
            bufferedWriter.write("hello world");
            bufferedWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.1.4. 緩衝流中的特殊方法

BufferedReader 類中多了一個方法 readLine()

• 意義: 讀取緩衝流中的一行數據， 可以逐行讀取。 一直到讀取到的數據是null， 表示數據讀取完了， 沒有下一行數據了。
• 注意事項: readLine() 是逐行讀取， 但是， 只能讀取到一行中的內容， 並不能讀取走換行符。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * @Date 2020/4/26
 * @Description
 */
public class BufferedReaderSpecial {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"))) {
            // 1. 定義一個字符串，用來接收每一行讀取到的數據
            String line = "";
            // 2. 循環讀取數據
            while ((line = reader.readLine()) != null) {
                // 3. 將讀取到的數據輸出
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

BufferedWriter 類中多了一個方法 newLine()

• 意義： 無參的方法， 寫一個換行符。

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

/**
 * @Description
 */
public class BufferedWriterSpecial {
    public static void main(String[] args) {
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
            bufferedWriter.write("hello world");
            bufferedWriter.newLine();
            bufferedWriter.write("你好，世界");
            bufferedWriter.newLine();
            bufferedWriter.write("end");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用緩衝字符流進行文件的拷貝

import java.io.*;

/**
 * @Description 使用緩衝字符流實現文本文件的拷貝
 */
public class BufferedCopy {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("file\\day26\\destination"))) {
            String line = "";
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
            writer.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

3.2. Scanner類

3.2.1. 簡介

這個類， 並不是一個IO流。 是一個掃描器， 這個類最主要的作用， 是從一個文件中或者從一個流中瀏覽數據。 在這個類中封裝了若干個方法， 方便了數據的讀取。

3.2.2. API

注意事項

這裏nextLine和BufferedReader中的readLine都可以讀取一行數據。 但是區別在於： 結束條件不同。

• BufferedReader: 如果讀取到的數據是null, 說明沒有下一行數據了。
• Scanner: 如果沒有下一行了，再去讀取，會出現異常。 所以， 此時的結束條件是 hasNextLine() 爲false。

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Pattern;

/**
 * @Description Scanner類的方法
 */
public class ScannerTest {
    public static void main(String[] args) {
        // 其實，Scanner在使用結束之後，也是需要進行關閉的。 調用close方法。
        try (Scanner scanner = new Scanner(new File("file\\day26\\src"))) {
            // 讀取文件中的內容
            while (scanner.hasNextLine()) {
                System.out.println(scanner.hasNextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

3.3. 標準輸入輸出流

3.3.1. 簡介

標準輸入流: http://System.in : 連接了程序和控制檯。 讀取控制檯中的內容。

標準輸出流: System.out ： 連接了程序和控制檯。 將程序中的內容輸出到控制檯。

3.3.2. 標準輸入流

import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Scanner;

/**
 * @Description 標準輸入流
 */
public class SystemInTest {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(System.in)) {
            byte[] array = new byte[128];
            int length = 0;
            while ((length = bis.read(array)) != -1) {
                String str = new String(array, 0, length);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3.3. 標準輸出流

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

/**
 * @Description 標準輸出流
 */
public class SystemOutTest {
    public static void main(String[] args) {
        PrintStream original = System.out;
        // PrintStream: 是一個打印流，可以將數據輸出到指定位置。
        try (PrintStream ps = new PrintStream(new FileOutputStream("file\\day26\\logs", true))) {
            // ps.println("hello world！");
            // 重定向標準輸出流
            System.setOut(ps);

            System.out.println("123");
        }
        catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.setOut(original);
        }

        System.out.println("你好");

        // System.out;      標準輸出流地址
        // System.out -> ps
    }
}

3.4. 轉換流

3.4.1. 爲什麼要用轉換流

在進行文件讀取的時候， 如果項目採用的字符集和文件的字符集不同，會出現亂碼的情況。

3.4.2. 輸入流

import java.io.*;

/**
 * @Description 轉換流
 *      轉換輸入流：可以以指定的字符集讀取某一個文件中的數據
 *      轉換輸出流：可以以指定的字符集把數據寫入到某一個文件
 */
public class TransforeTest {
    public static void main(String[] args) {
        read();
    }
    private static void read() {
        // 當前的項目是 utf-8, 讀取的文件是 GBK
        // 如果需要以指定的字符集進行文件的讀取，需要使用 InputStreamReader(InputStream inputStream, String charsetName)
        try (InputStreamReader reader = new InputStreamReader(new FileInputStream("file\\day26\\src"), "GBK")) {
            char[] array = new char[128];
            int length = 0;
            while ((length = reader.read(array)) != -1) {
                System.out.println(new String(array, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

3.4.3. 輸出流

import java.io.*;

/**
 * @Description 轉換流
 *      轉換輸入流：可以以指定的字符集讀取某一個文件中的數據
 *      轉換輸出流：可以以指定的字符集把數據寫入到某一個文件
 */
public class TransforeTest {
    public static void main(String[] args) {
        write();
    }

    private static void write() {
        // 以指定的字符集寫數據
        try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("file\\day26\\dst", true), "GBK")) {
            writer.write("hello world");
            writer.write("你好，世界");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.5. 對象流

3.5.1. 簡介

ObjectInputStream、 ObjectOutputStream， 主要是用來做對象的序列化和反序列化的。

• 序列化： 將內存中的某個對象， 以文件的形式保存到本地。
• 反序列化： 將本地保存的某一個文件， 信息讀取出來， 存到某一個對象中。

序列化、 反序列化， 是對象的持久化存儲的一種常用手段。

3.5.2. 注意事項

• 所有的要序列化到本地的類的對象， 類必須實現 java.io.Serilizable 接口。
• 如果需要序列化多個文件到本地， 儘量不要序列化到一個文件中。 如果需要序列化多個文件到本地， 通常採用的方式， 是村集合。 將多個對象存入一個集合中， 將這個集合序列化到本地。

3.5.3. 示例代碼

import java.io.*;

/**
 * @Description
 */
public class Test {
    public static void main(String[] args) {
        load();
    }

    /**
     * 反序列化
     */
    private static void load() {
        try(ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("file\\day26\\person"))) {
            // 讀取文件中的數據
            Object obj = inputStream.readObject();

            if (obj instanceof Person) {
                Person xiaoming = (Person)obj;
                System.out.println(xiaoming);
            }

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 序列化
     */
    private static void save() {
        // 實例化一個Person對象
        Person xiaoming = new Person("xiaoming", 12, 100);

        // 序列化對象
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("file\\day26\\person"))) {
            // 序列化
            outputStream.writeObject(xiaoming);
            outputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.6. Properties

3.6.1. 簡介

Properties也不是一個IO流， 是一個集合。 是Hashtable的子類。

使用Properties主要是爲了描述程序中的屬性列表文件。 有時候， 我們會將一些比較簡單的項目的配置信息， 以 .properties 格式的文件進行存儲。 可以使用Properties對象讀寫 .properties 文件。

3.6.2. 示例代碼

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 1. 實例化一個Properties對象
        Properties properties = new Properties();

        // 2. 加載一個 .properties 文件中的數據
        try {
            properties.load(new FileReader("file\\day27\\my.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 3. 遍歷
        System.out.println(properties);

        // 4. 鍵值對的增刪改查
        //    由於這個類是Map的實現類，因此在Map集合中定義的所有的方法，它都有。
        //    但是，對於Properties類的來說，增刪改查基本上不用從Map中繼承到的方法。
        //    因爲，從Map集合中繼承下來的方法，鍵和值都是Object類型的。
        // 4.1. 可以在集合中新增一個鍵值對，也可以修改集合中的存在的鍵值對。
        properties.setProperty("userlevel", "12");
        properties.setProperty("password", "ABCDEFG");

        // 4.2. 通過鍵，獲取值
        String level = properties.getProperty("userlevel");
        String id = properties.getProperty("userid", "123");

        System.out.println(properties);

        // 5. 將內存中的數據，同步到文件中
        try {
            properties.store(new FileWriter("file\\day27\\my.properties"), "hello");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}