主要內容

IO 流

字節流

字符流

異常處理

Properties

教學目標

能夠說出IO流的分類和功能

能夠使用字節輸出流寫出數據到文件

能夠使用字節輸入流讀取數據到程序

能夠理解讀取數據read(byte[])方法的原理

能夠使用字節流完成文件的復制

能夠使用FileWirter寫數據到文件

能夠說出FileWriter中關閉和刷新方法的區別

能夠使用FileWriter寫數據的5個方法

能夠使用FileWriter寫數據實現換行和追加寫

能夠使用FileReader讀數據

能夠使用FileReader讀數據一次一個字符數組

能夠使用Properties的load方法加載文件中配置信息

第一章 IO概述

1.1什么是IO

生活中，你肯定經歷過這樣的場景。當你編輯一個文本文件，忘記了ctrl+s，可能文件就白白編輯了。當你電腦上插入一個U盤，可以把一個視頻，拷貝到你的電腦硬盤里。那么數據都是在哪些設備上的呢？鍵盤、內存、硬 盤、外接設備等等。

我們把這種數據的傳輸，可以看做是一種數據的流動，按照流動的方向，以內存為基準，分為輸入input和

輸出output，即流向內存是輸入流，流出內存的輸出流。

JAVA中I/O操作主要是指使用java.io包下的內容，進行輸入、輸出操作。輸入也叫做讀取數據，輸出也叫做作寫出數據。

1.2IO的分類

根據數據的流向分為：輸入流和輸出流。

輸入流 ：把數據從 其他設備 上讀取到 內存 中的流。

輸出流 ：把數據從 內存 中寫出到 其他設備 上的流。

格局數據的類型分為：字節流和字符流。

字節流 ：以字節為單位，讀寫數據的流。

字符流 ：以字符為單位，讀寫數據的流。

1.3 IO的流向說明圖解

 

1.4頂級父類們

 

第二章 字節流

2.1一切皆為字節

一切文件數據(文本、圖片、視頻等)在存儲時，都是以二進制數字的形式保存，都一個一個的字節，那么傳輸時一 樣如此。所以，字節流可以傳輸任意文件數據。在操作流的時候，我們要時刻明確，無論使用什么樣的流對象，底 層傳輸的始終為二進制數據。

2.2字節輸出流【OutputStream】

java.io.OutputStream 抽象類是表示字節輸出流的所有類的超類，將指定的字節信息寫出到目的地。它定義了字 節輸出流的基本共性功能方法。

public void close() ：關閉此輸出流并釋放與此流相關聯的任何系統資源。

public void flush() ：刷新此輸出流并強制任何緩沖的輸出字節被寫出。

public void write(byte[] b) ：將 b.length字節從指定的字節數組寫入此輸出流。

public void write(byte[] b, int off, int len) ：從指定的字節數組寫入 len字節，從偏移量 off開始輸 出到此輸出流。

public abstract void write(int b) ：將指定的字節輸出流。

小貼士：

close方法，當完成流的操作時，必須調用此方法，釋放系統資源。

2.3 FileOutputStream類

OutputStream 有很多子類，我們從最簡單的一個子類開始。

java.io.FileOutputStream 類是文件輸出流，用于將數據寫出到文件。

構造方法

public FileOutputStream(File file) ：創建文件輸出流以寫入由指定的 File對象表示的文件。

public FileOutputStream(String name) ： 創建文件輸出流以指定的名稱寫入文件。

當你創建一個流對象時，必須傳入一個文件路徑。該路徑下，如果沒有這個文件，會創建該文件。如果有這個文 件，會清空這個文件的數據。

構造舉例，代碼如下：

public class FileOutputStreamConstructor throws IOException { public static void main(String[] args) {
// 使用File對象創建流對象
File file = new File("a.txt");
FileOutputStream fos = new FileOutputStream(file);
// 使用文件名稱創建流對象
FileOutputStream fos = new FileOutputStream("b.txt");
}
}

寫出字節數據

1. 寫出字節： write(int b) 方法，每次可以寫出一個字節數據，代碼使用演示：

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 寫出數據
fos.write(97); // 寫出第1個字節fos.write(98); // 寫出第2個字節fos.write(99); // 寫出第3個字節
// 關閉資源
fos.close();
}
}
輸出結果：
abc

小貼士：

1.雖然參數為int類型四個字節，但是只會保留一個字節的信息寫出。

2.流操作完畢后，必須釋放系統資源，調用close方法，千萬記得。

寫出字節數組： write(byte[] b) ，每次可以寫出數組中的數據，代碼使用演示：

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串轉換為字節數組
byte[] b = "程序員".getBytes();
// 寫出字節數組數據
fos.write(b);
// 關閉資源
fos.close();
}
}
輸出結果： 程序員

1. 寫出指定長度字節數組： write(byte[] b, int off, int len) ,每次寫出從off索引開始，len個字節，代碼 使用演示：

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串轉換為字節數組
byte[] b = "abcde".getBytes();
// 寫出從索引2開始，2個字節。索引2是c，兩個字節，也就是cd。
fos.write(b,2,2);
// 關閉資源
fos.close();
}
}
輸出結果：
cd

數據追加續寫

經過以上的演示，每次程序運行，創建輸出流對象，都會清空目標文件中的數據。如何保留目標文件中數據，還能 繼續添加新數據呢？

public FileOutputStream(File file, boolean Append) ： 創建文件輸出流以寫入由指定的 File對象表示的 文件。

public FileOutputStream(String name, boolean append) ： 創建文件輸出流以指定的名稱寫入文件。

這兩個構造方法，參數中都需要傳入一個boolean類型的值， true 表示追加數據， false 表示清空原有數據。 這樣創建的輸出流對象，就可以指定是否追加續寫了，代碼使用演示：

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileOutputStream fos = new FileOutputStream("fos.txt"，true);
// 字符串轉換為字節數組
byte[] b = "abcde".getBytes();
// 寫出從索引2開始，2個字節。索引2是c，兩個字節，也就是cd。
fos.write(b);
// 關閉資源
fos.close();
}
}
文件操作前：cd
文件操作后：cdabcde

寫出換行

windows系統里，換行符號是 。

以指定是否追加續寫了，代碼使用演示：

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 定義字節數組
byte[] words = {97,98,99,100,101};
// 遍歷數組
for (int i = 0; i < words.length; i++) {
// 寫出一個字節
fos.write(words[i]);
// 寫出一個換行, 換行符號轉成數組寫出
fos.write("
".getBytes());
}
// 關閉資源
fos.close();
}
}
輸出結果：
a b c d e

回車符 和換行符 ：

回車符：回到一行的開頭（return）。

換行符：下一行（newline）。

系統中的換行： Windows系統里，每行結尾是 回車+換行 ，即 ；

Unix系統里，每行結尾只有 換行 ，即 ；

mac系統里，每行結尾是 回車 ，即 。

從 Mac OS X開始與linux統一。

2.4 字節輸入流【InputStream】

java.io.InputStream 抽象類是表示字節輸入流的所有類的超類，可以讀取字節信息到內存中。它定義了字節輸入 流的基本共性功能方法。

public void close() ：關閉此輸入流并釋放與此流相關聯的任何系統資源。

public abstract int read() ： 從輸入流讀取數據的下一個字節。

public int read(byte[] b) ： 從輸入流中讀取一些字節數，并將它們存儲到字節數組 b中 。

小貼士：

close方法，當完成流的操作時，必須調用此方法，釋放系統資源。

2.5 FileInputStream類

java.io.FileInputStream 類是文件輸入流，從文件中讀取字節。

構造方法

FileInputStream(File file) ： 通過打開與實際文件的連接來創建一個 FileInputStream ，該文件由文件系 統中的 File對象 file命名。

FileInputStream(String name) ： 通過打開與實際文件的連接來創建一個 FileInputStream ，該文件由文件 系統中的路徑名 name命名。

當你創建一個流對象時，必須傳入一個文件路徑。該路徑下，如果沒有該文件,會拋出 FileNotFoundException 。

構造舉例，代碼如下：

public class FileInputStreamConstructor throws IOException{ public static void main(String[] args) {
// 使用File對象創建流對象
File file = new File("a.txt");
FileInputStream fos = new FileInputStream(file);
// 使用文件名稱創建流對象
FileInputStream fos = new FileInputStream("b.txt");
}
}

讀取字節數據

1. 讀取字節： read 方法，每次可以讀取一個字節的數據，提升為int類型，讀取到文件末尾，返回 -1 ，代碼使 用演示：

public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名稱創建流對象
FileInputStream fis = new FileInputStream("read.txt");
// 讀取數據，返回一個字節
int read = fis.read(); System.out.println((char) read); 
read = fis.read(); System.out.println((char) read); 
read = fis.read(); System.out.println((char) read); 
read = fis.read(); System.out.println((char) read); 
read = fis.read(); System.out.println((char) read);
// 讀取到末尾,返回‐1
read = fis.read(); System.out.println( read);
// 關閉資源
fis.close();
}
}
輸出結果：
a b c d e
‐1

循環改進讀取方式，代碼使用演示：

public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名稱創建流對象
FileInputStream fis = new FileInputStream("read.txt");
// 定義變量，保存數據
int b ；
// 循環讀取
while ((b = fis.read())!=‐1) { System.out.println((char)b);
}
// 關閉資源
fis.close();
}
}
輸出結果：
a b c d e

小貼士：

雖然讀取了一個字節，但是會自動提升為int類型。

流操作完畢后，必須釋放系統資源，調用close方法，千萬記得。

2. 使用字節數組讀取： read(byte[] b) ，每次讀取b的長度個字節到數組中，返回讀取到的有效字節個數，讀 取到末尾時，返回 -1 ，代碼使用演示：

public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名稱創建流對象.
FileInputStream fis = new FileInputStream("read.txt"); // 文件中為abcde
// 定義變量，作為有效個數
int len ；
// 定義字節數組，作為裝字節數據的容器
byte[] b = new byte[2];
// 循環讀取
while (( len= fis.read(b))!=‐1) {
// 每次讀取后,把數組變成字符串打印
System.out.println(new String(b));
}
// 關閉資源
fis.close();
}
}
輸出結果：
ab cd ed

錯誤數據 d ，是由于最后一次讀取時，只讀取一個字節 e ，數組中，上次讀取的數據沒有被完全替換，所以要通 過 len ，獲取有效的字節，代碼使用演示：

public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名稱創建流對象.
FileInputStream fis = new FileInputStream("read.txt"); // 文件中為abcde
// 定義變量，作為有效個數
int len ；
// 定義字節數組，作為裝字節數據的容器
byte[] b = new byte[2];
// 循環讀取
while (( len= fis.read(b))!=‐1) {
// 每次讀取后,把數組的有效字節部分，變成字符串打印
System.out.println(new String(b，0，len));// len 每次讀取的有效字節個數
}
// 關閉資源
fis.close();
}
}
輸出結果：
ab cd e

小貼士：

使用數組讀取，每次讀取多個字節，減少了系統間的IO操作次數，從而提高了讀寫的效率，建議開發中使 用。

2.6字節流練習：圖片復制

復制原理圖解

 

案例實現

復制圖片文件，代碼使用演示：

public class Copy {
public static void main(String[] args) throws IOException {
// 1.創建流對象
// 1.1 指定數據源
FileInputStream fis = new FileInputStream("D:test.jpg");
// 1.2 指定目的地
FileOutputStream fos = new FileOutputStream("test_copy.jpg");
// 2.讀寫數據
// 2.1 定義數組
byte[] b = new byte[1024];
// 2.2 定義長度
int len;
// 2.3 循環讀取
while ((len = fis.read(b))!=‐1) {
// 2.4 寫出數據
fos.write(b, 0 , len);
}
// 3.關閉資源fos.close();
fis.close();
}
}

小貼士：

流的關閉原則：先開后關，后開先關。

第三章 字符流

當使用字節流讀取文本文件時，可能會有一個小問題。就是遇到中文字符時，可能不會顯示完整的字符，那是因為 一個中文字符可能占用多個字節存儲。所以Java提供一些字符流類，以字符為單位讀寫數據，專門用于處理文本文 件。

3.1 字符輸入流【Reader】

java.io.Reader 抽象類是表示用于讀取字符流的所有類的超類，可以讀取字符信息到內存中。它定義了字符輸入 流的基本共性功能方法。

public void close() ：關閉此流并釋放與此流相關聯的任何系統資源。

public int read() ： 從輸入流讀取一個字符。

public int read(char[] cbuf) ： 從輸入流中讀取一些字符，并將它們存儲到字符數組 cbuf中 。

3.2 FileReader類

java.io.FileReader 類是讀取字符文件的便利類。構造時使用系統默認的字符編碼和默認字節緩沖區。

小貼士：

1. 字符編碼：字節與字符的對應規則。Windows系統的中文編碼默認是GBK編碼表。 idea中UTF-8
2. 字節緩沖區：一個字節數組，用來臨時存儲字節數據。
3. 構造方法
4. FileReader(File file) ： 創建一個新的 FileReader ，給定要讀取的File對象。
5. FileReader(String fileName) ： 創建一個新的 FileReader ，給定要讀取的文件的名稱
6. 當你創建一個流對象時，必須傳入一個文件路徑。類似于FileInputStream
7. 構造舉例，代碼如下：

public class FileReaderConstructor throws IOException{ public static void main(String[] args) {
// 使用File對象創建流對象
File file = new File("a.txt"); FileReader fr = new FileReader(file);
// 使用文件名稱創建流對象
FileReader fr = new FileReader("b.txt");
}
}

讀取字符數據

1. 讀取字符： read 方法，每次可以讀取一個字符的數據，提升為int類型，讀取到文件末尾，返回 -1 ，循環讀 取，代碼使用演示：

public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileReader fr = new FileReader("read.txt");
// 定義變量，保存數據
int b ；
// 循環讀取
while ((b = fr.read())!=‐1) { System.out.println((char)b);
}
// 關閉資源
fr.close();
}
}
輸出結果： 
程
序
員

小貼士：雖然讀取了一個字符，但是會自動提升為int類型。

2. 使用字符數組讀取： read(char[] cbuf) ，每次讀取b的長度個字符到數組中，返回讀取到的有效字符個數， 讀取到末尾時，返回 -1 ，代碼使用演示：

public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileReader fr = new FileReader("read.txt");
// 定義變量，保存有效字符個數
int len ；
// 定義字符數組，作為裝字符數據的容器
char[] cbuf = new char[2];
// 循環讀取
while ((len = fr.read(cbuf))!=‐1) { System.out.println(new String(cbuf));
}
// 關閉資源
fr.close();
}
}
輸出結果： 
程序
員序

獲取有效的字符改進，代碼使用演示：

public class FISRead {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileReader fr = new FileReader("read.txt");
// 定義變量，保存有效字符個數
int len ；
// 定義字符數組，作為裝字符數據的容器
char[] cbuf = new char[2];
// 循環讀取
while ((len = fr.read(cbuf))!=‐1) { System.out.println(new String(cbuf,0,len));
}
// 關閉資源
fr.close();
}
}
輸出結果： 
程序
員

3.3字符輸出流【Writer】

java.io.Writer 抽象類是表示用于寫出字符流的所有類的超類，將指定的字符信息寫出到目的地。它定義了字節 輸出流的基本共性功能方法。

void write(int c) 寫入單個字符。

void write(char[] cbuf) 寫入字符數組。

abstract void write(char[] cbuf, int off, int len) 寫入字符數組的某一部分,off數組的開始索引,len 寫的字符個數。

void write(String str) 寫入字符串。

void write(String str, int off, int len) 寫入字符串的某一部分,off字符串的開始索引,len寫的字符個 數。

void flush() 刷新該流的緩沖。

void close() 關閉此流，但要先刷新它。

3.4 FileWriter類

java.io.FileWriter 類是寫出字符到文件的便利類。構造時使用系統默認的字符編碼和默認字節緩沖區。

構造方法

FileWriter(File file) ： 創建一個新的 FileWriter，給定要讀取的File對象

FileWriter(String fileName) ： 創建一個新的 FileWriter，給定要讀取的文件的名稱。

當你創建一個流對象時，必須傳入一個文件路徑，類似于FileOutputStream。

構造舉例，代碼如下：

public class FileWriterConstructor {
public static void main(String[] args) throws IOException {
// 使用File對象創建流對象
File file = new File("a.txt"); FileWriter fw = new FileWriter(file);
// 使用文件名稱創建流對象
FileWriter fw = new FileWriter("b.txt");
}
}

基本寫出數據

寫出字符： write(int b) 方法，每次可以寫出一個字符數據，代碼使用演示：

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileWriter fw = new FileWriter("fw.txt");
// 寫出數據
fw.write(97); // 寫出第1個字符fw.write('b'); // 寫出第2個字符f
w.write('C'); // 寫出第3個字符
fw.write(30000); // 寫出第4個字符，中文編碼表中30000對應一個漢字。
/*
【注意】關閉資源時,與FileOutputStream不同。
如果不關閉,數據只是保存到緩沖區，并未保存到文件。
*/
// fw.close();
}
}
輸出結果：
abC田

小貼士：

1.雖然參數為int類型四個字節，但是只會保留一個字符的信息寫出。

2.未調用close方法，數據只是保存到了緩沖區，并未寫出到文件中。

關閉和刷新

因為內置緩沖區的原因，如果不關閉輸出流，無法寫出字符到文件中。但是關閉的流對象，是無法繼續寫出數據 的。如果我們既想寫出數據，又想繼續使用流，就需要 flush 方法了。

flush ：刷新緩沖區，流對象可以繼續使用。

close :先刷新緩沖區，然后通知系統釋放資源。流對象不可以再被使用了。

代碼使用演示：

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileWriter fw = new FileWriter("fw.txt");
// 寫 出 數 據 ， 通 過 flush fw.write('刷'); // 寫出第1個字符fw.flush();
fw.write('新'); // 繼續寫出第2個字符，寫出成功
fw.flush();
// 寫 出 數 據 ， 通 過 close fw.write('關'); // 寫出第1個字符fw.close();
fw.write('閉'); // 繼續寫出第2個字符,【報錯】java.io.IOException: Stream closed fw.close();
}
}

小貼士：即便是?ush方法寫出了數據，操作的最后還是要調用close方法，釋放系統資源。

寫出其他數據

1. 寫出字符數組 ： write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以寫出字符數 組中的數據，用法類似FileOutputStream，代碼使用演示：

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileWriter fw = new FileWriter("fw.txt");
// 字符串轉換為字節數組
char[] chars = "黑馬程序員".toCharArray();
// 寫出字符數組
fw.write(chars); // 黑馬程序員
// 寫出從索引2開始，2個字節。索引2是'程'，兩個字節，也就是'程序'。
fw.write(b,2,2); // 程 序
// 關閉資源
fos.close();
}
}

1. 寫出字符串： write(String str) 和 write(String str, int off, int len) ，每次可以寫出字符串中的 數據，更為方便，代碼使用演示：

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象
FileWriter fw = new FileWriter("fw.txt");
// 字符串
String msg = "字節程序員";
// 寫出字符數組
fw.write(msg); /字節程序員
// 寫出從索引2開始，2個字節。索引2是'程'，兩個字節，也就是'程序'。
fw.write(msg,2,2);	// 程 序
// 關閉資源
fos.close();
}
}

3.續寫和換行：操作類似于FileOutputStream。

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名稱創建流對象，可以續寫數據
FileWriter fw = new FileWriter("fw.txt"，true);
// 寫出字符串
fw.write("字節");
// 寫出換行
fw.write("
");
// 寫出字符串
fw.write("程序員");
// 關閉資源
fw.close();
}
}
輸出結果: 字節
程序員

小貼士：字符流，只能操作文本文件，不能操作圖片，視頻等非文本文件。當我們單純讀或者寫文本文件時 使用字符流 其他情況使用字節流

第四章 IO異常的處理

JDK7前處理

之前的入門練習，我們一直把異常拋出，而實際開發中并不能這樣處理，建議使用 try…catch…finally 代碼 塊，處理異常部分，代碼使用演示：

public class HandleException1 {
public static void main(String[] args) {
// 聲明變量FileWriter fw = null; try {
//創建流對象
fw = new FileWriter("fw.txt");
// 寫出數據
fw.write("程序員"); //程序員
} catch (IOException e) { e.printStackTrace();
} finally { try {
if (fw != null) {
fw.close();
}
} catch (IOException e) { e.printStackTrace();
}
}
}
}

JDK7的處理(擴展知識點了解內容) 還可以使用JDK7優化后的 try-with-resource 語句，該語句確保了每個資源在語句結束時關閉。所謂的資源 （resource）是指在程序完成后，必須關閉的對象。

格式：

try (創建流對象語句，如果多個,使用';'隔開) {
// 讀寫數據
} catch (IOException e) { e.printStackTrace();
}

代碼使用演示：

public class HandleException2 {
public static void main(String[] args) {
// 創建流對象
try ( FileWriter fw = new FileWriter("fw.txt"); ) {
// 寫出數據
fw.write("程序員"); //程序員
} catch (IOException e) { e.printStackTrace();
}
}
}

JDK9的改進(擴展知識點了解內容)

JDK9中 try-with-resource 的改進，對于引入對象的方式，支持的更加簡潔。被引入的對象，同樣可以自動關閉， 無需手動close，我們來了解一下格式。

改進前格式：

// 被final修飾的對象
final Resource resource1 = new Resource("resource1");
// 普通對象
Resource resource2 = new Resource("resource2");
// 引入方式：創建新的變量保存
try (Resource r1 = resource1; Resource r2 = resource2) {
// 使用對象
}

改進后格式：

// 被final修飾的對象
final Resource resource1 = new Resource("resource1");
// 普通對象
Resource resource2 = new Resource("resource2");
// 引入方式：直接引入
try (resource1; resource2) {
// 使用對象
}

改進后，代碼使用演示：

public class TryDemo {
public static void main(String[] args) throws IOException {
// 創建流對象
final FileReader fr = new FileReader("in.txt"); 
FileWriter fw = new FileWriter("out.txt");
// 引入到try中
try (fr; fw) {
// 定義變量
int b;
// 讀取數據
while ((b = fr.read())!=‐1) {
// 寫出數據
fw.write(b);
}
} catch (IOException e) { e.printStackTrace();
}
}
}

第五章 屬性集

5.1概述

java.util.Properties 繼承于 Hashtable ，來表示一個持久的屬性集。它使用鍵值結構存儲數據，每個鍵及其 對應值都是一個字符串。該類也被許多Java類使用，比如獲取系統屬性時， System.getProperties 方法就是返回 一個 Properties 對象。

5.2Properties類

構造方法

public Properties() :創建一個空的屬性列表。

基本的存儲方法

public Object setProperty(String key, String value) ： 保存一對屬性。

public String getProperty(String key) ：使用此屬性列表中指定的鍵搜索屬性值。

public Set stringPropertyNames() ：所有鍵的名稱的集合。

public class ProDemo {

public static void main(String[] args) throws FileNotFoundException {

// 創建屬性集對象

Properties properties = new Properties();

// 添加鍵值對元素properties.setProperty("filename", "a.txt"); properties.setProperty("length", "209385038"); properties.setProperty("location", "D:a.txt");

// 打印屬性集對象

System.out.println(properties);

// 通過鍵,獲取屬性值System.out.println(properties.getProperty("filename")); System.out.println(properties.getProperty("length")); System.out.println(properties.getProperty("location"));

// 遍歷屬性集,獲取所有鍵的集合

Set<String> strings = properties.stringPropertyNames();

// 打印鍵值對

for (String key : strings ) {

System.out.println(key+" ‐‐ "+properties.getProperty(key));

}

}

}

輸出結果：

{filename=a.txt, length=209385038, location=D:a.txt} a.txt

209385038

D:a.txt filename ‐‐ a.txt

length ‐‐ 209385038 location ‐‐ D:a.txt

與流相關的方法

public void load(InputStream inStream) ： 從字節輸入流中讀取鍵值對。

參數中使用了字節輸入流，通過流對象，可以關聯到某文件上，這樣就能夠加載文本中的數據了。文本數據格式:

filename=a.txt
 length=209385038
 location=D:a.txt

加載代碼演示：

public class ProDemo2 {
public static void main(String[] args) throws FileNotFoundException {
// 創建屬性集對象
Properties pro = new Properties();
// 加載文本中信息到屬性集
pro.load(new FileInputStream("read.txt"));
// 遍歷集合并打印
Set<String> strings = pro.stringPropertyNames(); for (String key : strings ) {
System.out.println(key+" ‐‐ "+pro.getProperty(key));
}
}
}
輸出結果：
filename ‐‐ a.txt length ‐‐ 209385038 location ‐‐ D:a.txt

小貼士：文本中的數據，必須是鍵值對形式，可以使用空格、等號、冒號等符號分隔。