File流與IO流 看這一篇就夠了
主要內容
- File類
- 遞迴
- IO流
- 位元組流
- 字元流
- 異常處理
- Properties
- 緩衝流
- 轉換流
- 序列化流
- 列印流
學習目標
- [ ] 能夠說出File物件的建立方式
- [ ] 能夠說出File類獲取名稱的方法名稱
- [ ] 能夠說出File類獲取絕對路徑的方法名稱
- [ ] 能夠說出File類獲取檔案大小的方法名稱
- [ ] 能夠說出File類判斷是否是檔案的方法名稱
- [ ] 能夠說出File類判斷是否是資料夾的方法名稱
- [ ] 能夠辨別相對路徑和絕對路徑
- [ ] 能夠遍歷資料夾
- [ ] 能夠解釋遞迴的含義
- [ ] 能夠說出使用遞迴會記憶體溢位隱患的原因
- [ ] 能夠說出IO流的分類和功能
- [ ] 能夠使用位元組輸出流寫出資料到檔案
- [ ] 能夠使用位元組輸入流讀取資料到程式
- [ ] 能夠理解讀取資料read(byte[])方法的原理
- [ ] 能夠使用位元組流完成檔案的複製
- [ ] 能夠使用FileWirter寫資料到檔案
- [ ] 能夠說出FileWriter中關閉和重新整理方法的區別
- [ ] 能夠使用FileWriter寫資料的5個方法
- [ ] 能夠使用FileWriter寫資料實現換行和追加寫
- [ ] 能夠使用FileReader讀資料
- [ ] 能夠使用FileReader讀資料一次一個字元陣列
- [ ] 能夠使用Properties的load方法載入檔案中配置資訊
- [ ] 能夠使用位元組緩衝流讀取資料到程式
- [ ] 能夠使用位元組緩衝流寫出資料到檔案
- [ ] 能夠明確字元緩衝流的作用和基本用法
- [ ] 能夠使用緩衝流的特殊功能
- [ ] 能夠闡述編碼表的意義
- [ ] 能夠使用轉換流讀取指定編碼的文字檔案
- [ ] 能夠使用轉換流寫入指定編碼的文字檔案
- [ ] 能夠說出列印流的特點
- [ ] 能夠使用序列化流寫出物件到檔案
- [ ] 能夠使用反序列化流讀取檔案到程式中
第一章 File類
1.1 概述
java.io.File
類是檔案和目錄路徑名的抽象表示,主要用於檔案和目錄的建立、查詢和刪除等操作。
1.2 構造方法
public File(String pathname)
:通過將給定的路徑名字串轉換為抽象路徑名來建立新的 File例項。public File(String parent, String child)
:從父路徑名字串和子路徑名字串建立新的 File例項。public File(File parent, String child)
:從父抽象路徑名和子路徑名字串建立新的 File例項。構造舉例,程式碼如下:
// 檔案路徑名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname);
// 檔案路徑名
String pathname2 = "D:\\aaa\\bbb.txt";
File file2 = new File(pathname2);
// 通過父路徑和子路徑字串
String parent = "d:\\aaa";
String child = "bbb.txt";
File file3 = new File(parent, child);
// 通過父級File物件和子路徑字串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);
小貼士:
- 一個File物件代表硬碟中實際存在的一個檔案或者目錄。
- 無論該路徑下是否存在檔案或者目錄,都不影響File物件的建立。
1.3 常用方法
獲取功能的方法
public String getAbsolutePath()
:返回此File的絕對路徑名字串。public String getPath()
:將此File轉換為路徑名字串。public String getName()
:返回由此File表示的檔案或目錄的名稱。public long length()
:返回由此File表示的檔案的長度。方法演示,程式碼如下:
public class FileGet { public static void main(String[] args) { File f = new File("d:/aaa/bbb.java"); System.out.println("檔案絕對路徑:"+f.getAbsolutePath()); System.out.println("檔案構造路徑:"+f.getPath()); System.out.println("檔名稱:"+f.getName()); System.out.println("檔案長度:"+f.length()+"位元組"); File f2 = new File("d:/aaa"); System.out.println("目錄絕對路徑:"+f2.getAbsolutePath()); System.out.println("目錄構造路徑:"+f2.getPath()); System.out.println("目錄名稱:"+f2.getName()); System.out.println("目錄長度:"+f2.length()); } } 輸出結果: 檔案絕對路徑:d:\aaa\bbb.java 檔案構造路徑:d:\aaa\bbb.java 檔名稱:bbb.java 檔案長度:636位元組 目錄絕對路徑:d:\aaa 目錄構造路徑:d:\aaa 目錄名稱:aaa 目錄長度:4096
API中說明:length(),表示檔案的長度。但是File物件表示目錄,則返回值未指定。
絕對路徑和相對路徑
- 絕對路徑:從碟符開始的路徑,這是一個完整的路徑。
- 相對路徑:相對於專案目錄的路徑,這是一個便捷的路徑,開發中經常使用。
public class FilePath {
public static void main(String[] args) {
// D盤下的bbb.java檔案
File f = new File("D:\\bbb.java");
System.out.println(f.getAbsolutePath());
// 專案下的bbb.java檔案
File f2 = new File("bbb.java");
System.out.println(f2.getAbsolutePath());
}
}
輸出結果:
D:\bbb.java
D:\idea_project_test4\bbb.java
判斷功能的方法
public boolean exists()
:此File表示的檔案或目錄是否實際存在。public boolean isDirectory()
:此File表示的是否為目錄。public boolean isFile()
:此File表示的是否為檔案。
方法演示,程式碼如下:
public class FileIs {
public static void main(String[] args) {
File f = new File("d:\\aaa\\bbb.java");
File f2 = new File("d:\\aaa");
// 判斷是否存在
System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
System.out.println("d:\\aaa 是否存在:"+f2.exists());
// 判斷是檔案還是目錄
System.out.println("d:\\aaa 檔案?:"+f2.isFile());
System.out.println("d:\\aaa 目錄?:"+f2.isDirectory());
}
}
輸出結果:
d:\aaa\bbb.java 是否存在:true
d:\aaa 是否存在:true
d:\aaa 檔案?:false
d:\aaa 目錄?:true
建立刪除功能的方法
public boolean createNewFile()
:當且僅當具有該名稱的檔案尚不存在時,建立一個新的空檔案。public boolean delete()
:刪除由此File表示的檔案或目錄。
public boolean mkdir()
:建立由此File表示的目錄。public boolean mkdirs()
:建立由此File表示的目錄,包括任何必需但不存在的父目錄。
方法演示,程式碼如下:
public class FileCreateDelete {
public static void main(String[] args) throws IOException {
// 檔案的建立
File f = new File("aaa.txt");
System.out.println("是否存在:"+f.exists()); // false
System.out.println("是否建立:"+f.createNewFile()); // true
System.out.println("是否存在:"+f.exists()); // true
// 目錄的建立
File f2= new File("newDir");
System.out.println("是否存在:"+f2.exists());// false
System.out.println("是否建立:"+f2.mkdir()); // true
System.out.println("是否存在:"+f2.exists());// true
// 建立多級目錄
File f3= new File("newDira\\newDirb");
System.out.println(f3.mkdir());// false
File f4= new File("newDira\\newDirb");
System.out.println(f4.mkdirs());// true
// 檔案的刪除
System.out.println(f.delete());// true
// 目錄的刪除
System.out.println(f2.delete());// true
System.out.println(f4.delete());// false
}
}
API中說明:delete方法,如果此File表示目錄,則目錄必須為空才能刪除。
1.4 目錄的遍歷
public String[] list()
:返回一個String陣列,表示該File目錄中的所有子檔案或目錄。public File[] listFiles()
:返回一個File陣列,表示該File目錄中的所有的子檔案或目錄。
public class FileFor {
public static void main(String[] args) {
File dir = new File("d:\\java_code");
//獲取當前目錄下的檔案以及資料夾的名稱。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
//獲取當前目錄下的檔案以及資料夾物件,只要拿到了檔案物件,那麼就可以獲取更多資訊
File[] files = dir.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
小貼士:
呼叫listFiles方法的File物件,表示的必須是實際存在的目錄,否則返回null,無法進行遍歷。
第二章 遞迴
2.1 概述
遞迴:指在當前方法內呼叫自己的這種現象。
- 遞迴的分類:
- 遞迴分為兩種,直接遞迴和間接遞迴。
- 直接遞迴稱為方法自身呼叫自己。
- 間接遞迴可以A方法呼叫B方法,B方法呼叫C方法,C方法呼叫A方法。
- 注意事項:
- 遞迴一定要有條件限定,保證遞迴能夠停止下來,否則會發生棧記憶體溢位。
- 在遞迴中雖然有限定條件,但是遞迴次數不能太多。否則也會發生棧記憶體溢位。
- 構造方法,禁止遞迴
public class Demo01DiGui {
public static void main(String[] args) {
// a();
b(1);
}
/*
* 3.構造方法,禁止遞迴
* 編譯報錯:構造方法是建立物件使用的,不能讓物件一直建立下去
*/
public Demo01DiGui() {
//Demo01DiGui();
}
/*
* 2.在遞迴中雖然有限定條件,但是遞迴次數不能太多。否則也會發生棧記憶體溢位。
* 4993
* Exception in thread "main" java.lang.StackOverflowError
*/
private static void b(int i) {
System.out.println(i);
//新增一個遞迴結束的條件,i==5000的時候結束
if(i==5000){
return;//結束方法
}
b(++i);
}
/*
* 1.遞迴一定要有條件限定,保證遞迴能夠停止下來,否則會發生棧記憶體溢位。 Exception in thread "main"
* java.lang.StackOverflowError
*/
private static void a() {
System.out.println("a方法");
a();
}
}
2.2 遞迴累加求和
計算1 ~ n的和
分析:num的累和 = num + (num-1)的累和,所以可以把累和的操作定義成一個方法,遞迴呼叫。
實現程式碼:
public class DiGuiDemo {
public static void main(String[] args) {
//計算1~num的和,使用遞迴完成
int num = 5;
// 呼叫求和的方法
int sum = getSum(num);
// 輸出結果
System.out.println(sum);
}
/*
通過遞迴演算法實現.
引數列表:int
返回值型別: int
*/
public static int getSum(int num) {
/*
num為1時,方法返回1,
相當於是方法的出口,num總有是1的情況
*/
if(num == 1){
return 1;
}
/*
num不為1時,方法返回 num +(num-1)的累和
遞迴呼叫getSum方法
*/
return num + getSum(num-1);
}
}
程式碼執行圖解
小貼士:遞迴一定要有條件限定,保證遞迴能夠停止下來,次數不要太多,否則會發生棧記憶體溢位。
2.3 遞迴求階乘
- 階乘:所有小於及等於該數的正整數的積。
n的階乘:n! = n * (n-1) *...* 3 * 2 * 1
分析:這與累和類似,只不過換成了乘法運算,學員可以自己練習,需要注意階乘值符合int型別的範圍。
推理得出:n! = n * (n-1)!
程式碼實現:
public class DiGuiDemo {
//計算n的階乘,使用遞迴完成
public static void main(String[] args) {
int n = 3;
// 呼叫求階乘的方法
int value = getValue(n);
// 輸出結果
System.out.println("階乘為:"+ value);
}
/*
通過遞迴演算法實現.
引數列表:int
返回值型別: int
*/
public static int getValue(int n) {
// 1的階乘為1
if (n == 1) {
return 1;
}
/*
n不為1時,方法返回 n! = n*(n-1)!
遞迴呼叫getValue方法
*/
return n * getValue(n - 1);
}
}
2.4 遞迴列印多級目錄
分析:多級目錄的列印,就是當目錄的巢狀。遍歷之前,無從知道到底有多少級目錄,所以我們還是要使用遞迴實現。
程式碼實現:
public class DiGuiDemo2 {
public static void main(String[] args) {
// 建立File物件
File dir = new File("D:\\aaa");
// 呼叫列印目錄方法
printDir(dir);
}
public static void printDir(File dir) {
// 獲取子檔案和目錄
File[] files = dir.listFiles();
// 迴圈列印
/*
判斷:
當是檔案時,列印絕對路徑.
當是目錄時,繼續呼叫列印目錄的方法,形成遞迴呼叫.
*/
for (File file : files) {
// 判斷
if (file.isFile()) {
// 是檔案,輸出檔案絕對路徑
System.out.println("檔名:"+ file.getAbsolutePath());
} else {
// 是目錄,輸出目錄絕對路徑
System.out.println("目錄:"+file.getAbsolutePath());
// 繼續遍歷,呼叫printDir,形成遞迴
printDir(file);
}
}
}
}
第三章 綜合案例
3.1 檔案搜尋
搜尋D:\aaa
目錄中的.java
檔案。
分析:
- 目錄搜尋,無法判斷多少級目錄,所以使用遞迴,遍歷所有目錄。
- 遍歷目錄時,獲取的子檔案,通過檔名稱,判斷是否符合條件。
程式碼實現:
public class DiGuiDemo3 {
public static void main(String[] args) {
// 建立File物件
File dir = new File("D:\\aaa");
// 呼叫列印目錄方法
printDir(dir);
}
public static void printDir(File dir) {
// 獲取子檔案和目錄
File[] files = dir.listFiles();
// 迴圈列印
for (File file : files) {
if (file.isFile()) {
// 是檔案,判斷檔名並輸出檔案絕對路徑
if (file.getName().endsWith(".java")) {
System.out.println("檔名:" + file.getAbsolutePath());
}
} else {
// 是目錄,繼續遍歷,形成遞迴
printDir(file);
}
}
}
}
3.2 檔案過濾器優化
java.io.FileFilter
是一個介面,是File的過濾器。 該介面的物件可以傳遞給File類的listFiles(FileFilter)
作為引數, 介面中只有一個方法。
boolean accept(File pathname)
:測試pathname是否應該包含在當前File目錄中,符合則返回true。
分析:
- 介面作為引數,需要傳遞子類物件,重寫其中方法。我們選擇匿名內部類方式,比較簡單。
accept
方法,引數為File,表示當前File下所有的子檔案和子目錄。保留住則返回true,過濾掉則返回false。保留規則:- 要麼是.java檔案。
- 要麼是目錄,用於繼續遍歷。
- 通過過濾器的作用,
listFiles(FileFilter)
返回的陣列元素中,子檔案物件都是符合條件的,可以直接列印。
程式碼實現:
public class DiGuiDemo4 {
public static void main(String[] args) {
File dir = new File("D:\\aaa");
printDir2(dir);
}
public static void printDir2(File dir) {
// 匿名內部類方式,建立過濾器子類物件
File[] files = dir.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.getName().endsWith(".java")||pathname.isDirectory();
}
});
// 迴圈列印
for (File file : files) {
if (file.isFile()) {
System.out.println("檔名:" + file.getAbsolutePath());
} else {
printDir2(file);
}
}
}
}
3.3 Lambda優化
分析:FileFilter
是隻有一個方法的介面,因此可以用lambda表示式簡寫。
lambda格式:
()->{ }
程式碼實現:
public static void printDir3(File dir) {
// lambda的改寫
File[] files = dir.listFiles(f ->{
return f.getName().endsWith(".java") || f.isDirectory();
});
// 迴圈列印
for (File file : files) {
if (file.isFile()) {
System.out.println("檔名:" + file.getAbsolutePath());
} else {
printDir3(file);
}
}
}
第四章 IO概述
4.1 什麼是IO
生活中,你肯定經歷過這樣的場景。當你編輯一個文字檔案,忘記了ctrl+s
,可能檔案就白白編輯了。當你電腦上插入一個U盤,可以把一個視訊,拷貝到你的電腦硬盤裡。那麼資料都是在哪些裝置上的呢?鍵盤、記憶體、硬碟、外接裝置等等。
我們把這種資料的傳輸,可以看做是一種資料的流動,按照流動的方向,以記憶體為基準,分為輸入input
和輸出output
,即流向記憶體是輸入流,流出記憶體的輸出流。
Java中I/O操作主要是指使用java.io
包下的內容,進行輸入、輸出操作。輸入也叫做讀取資料,輸出也叫做作寫出資料。
4.2 IO的分類
根據資料的流向分為:輸入流和輸出流。
- 輸入流 :把資料從
其他裝置
上讀取到記憶體
中的流。 - 輸出流 :把資料從
記憶體
中寫出到其他裝置
上的流。
格局資料的型別分為:位元組流和字元流。
- 位元組流 :以位元組為單位,讀寫資料的流。
- 字元流 :以字元為單位,讀寫資料的流。
4.3 IO的流向說明圖解
4.4 頂級父類們
輸入流 | 輸出流 | |
---|---|---|
位元組流 | 位元組輸入流 InputStream |
位元組輸出流 OutputStream |
字元流 | 字元輸入流 Reader |
字元輸出流 Writer |
第五章 位元組流
5.1 一切皆為位元組
一切檔案資料(文字、圖片、視訊等)在儲存時,都是以二進位制數字的形式儲存,都一個一個的位元組,那麼傳輸時一樣如此。所以,位元組流可以傳輸任意檔案資料。在操作流的時候,我們要時刻明確,無論使用什麼樣的流物件,底層傳輸的始終為二進位制資料。
5.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方法,當完成流的操作時,必須呼叫此方法,釋放系統資源。
5.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");
}
}
寫出位元組資料
- 寫出位元組:
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
小貼士:
- 雖然引數為int型別四個位元組,但是隻會保留一個位元組的資訊寫出。
- 流操作完畢後,必須釋放系統資源,呼叫close方法,千萬記得。
- 寫出位元組陣列:
write(byte[] b)
,每次可以寫出陣列中的資料,程式碼使用演示:
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用檔名稱建立流物件
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字串轉換為位元組陣列
byte[] b = "Java程式設計師".getBytes();
// 寫出位元組陣列資料
fos.write(b);
// 關閉資源
fos.close();
}
}
輸出結果:
Java程式設計師
- 寫出指定長度位元組陣列:
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系統裡,換行符號是\r\n
。
程式碼使用演示:
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("\r\n".getBytes());
}
// 關閉資源
fos.close();
}
}
輸出結果:
a
b
c
d
e
- 回車符
\r
和換行符\n
:
- 回車符:回到一行的開頭(return)。
- 換行符:下一行(newline)。
- 系統中的換行:
- Windows系統裡,每行結尾是
回車+換行
,即\r\n
;- Unix系統裡,每行結尾只有
換行
,即\n
;- Mac系統裡,每行結尾是
回車
,即\r
。從 Mac OS X開始與Linux統一。
5.4 位元組輸入流【InputStream】
java.io.InputStream
抽象類是表示位元組輸入流的所有類的超類,可以讀取位元組資訊到記憶體中。它定義了位元組輸入流的基本共性功能方法。
public void close()
:關閉此輸入流並釋放與此流相關聯的任何系統資源。
public abstract int read()
: 從輸入流讀取資料的下一個位元組。public int read(byte[] b)
: 從輸入流中讀取一些位元組數,並將它們儲存到位元組陣列 b中 。
小貼士:
close方法,當完成流的操作時,必須呼叫此方法,釋放系統資源。
5.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");
}
}
讀取位元組資料
- 讀取位元組:
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方法,千萬記得。
- 使用位元組陣列讀取:
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操作次數,從而提高了讀寫的效率,建議開發中使用。
5.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提供一些字元流類,以字元為單位讀寫資料,專門用於處理文字檔案。
6.1 字元輸入流【Reader】
java.io.Reader
抽象類是表示用於讀取字元流的所有類的超類,可以讀取字元資訊到記憶體中。它定義了字元輸入流的基本共性功能方法。
public void close()
:關閉此流並釋放與此流相關聯的任何系統資源。
public int read()
: 從輸入流讀取一個字元。public int read(char[] cbuf)
: 從輸入流中讀取一些字元,並將它們儲存到字元陣列 cbuf中 。
6.2 FileReader類
java.io.FileReader
類是讀取字元檔案的便利類。構造時使用系統預設的字元編碼和預設位元組緩衝區。
小貼士:
字元編碼:位元組與字元的對應規則。Windows系統的中文編碼預設是GBK編碼表。
idea中UTF-8
位元組緩衝區:一個位元組陣列,用來臨時儲存位元組資料。
構造方法
FileReader(File file)
: 建立一個新的 FileReader ,給定要讀取的File物件。
FileReader(String fileName)
: 建立一個新的 FileReader ,給定要讀取的檔案的名稱。
當你建立一個流物件時,必須傳入一個檔案路徑。類似於FileInputStream 。
- 構造舉例,程式碼如下:
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");
}
}
讀取字元資料
- 讀取字元:
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型別。
- 使用字元陣列讀取:
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();
}
}
輸出結果:
中文
樣例
一
6.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()
關閉此流,但要先重新整理它。
6.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個字元
fw.write('C'); // 寫出第3個字元
fw.write(30000); // 寫出第4個字元,中文編碼表中30000對應一個漢字。
/*
【注意】關閉資源時,與FileOutputStream不同。
如果不關閉,資料只是儲存到緩衝區,並未儲存到檔案。
*/
// fw.close();
}
}
輸出結果:
abC田
小貼士:
- 雖然引數為int型別四個位元組,但是隻會保留一個字元的資訊寫出。
- 未呼叫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();
}
}
小貼士:即便是flush方法寫出了資料,操作的最後還是要呼叫close方法,釋放系統資源。
寫出其他資料
- 寫出字元陣列 :
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 = "JAVA程式設計師".toCharArray();
// 寫出字元陣列
fw.write(chars); // JAVA程式設計師
// 寫出從索引2開始,2個位元組。索引2是'V',兩個位元組,也就是'VA'。
fw.write(chars,2,2); // VA
// 關閉資源
fw.close();
}
}
- 寫出字串:
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 = "JAVA程式設計師";
// 寫出字元陣列
fw.write(msg); //JAVA程式設計師
// 寫出從索引2開始,2個位元組。索引2是'V',兩個位元組,也就是'VA'。
fw.write(msg,2,2); // VA
// 關閉資源
fw.close();
}
}
- 續寫和換行:操作類似於FileOutputStream。
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用檔名稱建立流物件,可以續寫資料
FileWriter fw = new FileWriter("fw.txt",true);
// 寫出字串
fw.write("JAVA");
// 寫出換行
fw.write("\r\n");
// 寫出字串
fw.write("程式設計師");
// 關閉資源
fw.close();
}
}
輸出結果:
JAVA
程式設計師
小貼士:字元流,只能操作文字檔案,不能操作圖片,視訊等非文字檔案。
當我們單純讀或者寫文字檔案時 使用字元流 其他情況使用位元組流
第七章 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("JAVA程式設計師"); //JAVA程式設計師
} 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("JAVA程式設計師"); //JAVA程式設計師
} 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();
}
}
}
第八章 屬性集
8.1 概述
java.util.Properties
繼承於Hashtable
,來表示一個持久的屬性集。它使用鍵值結構儲存資料,每個鍵及其對應值都是一個字串。該類也被許多Java類使用,比如獲取系統屬性時,System.getProperties
方法就是返回一個Properties
物件。
8.2 Properties類
構造方法
public Properties()
:建立一個空的屬性列表。
基本的儲存方法
public Object setProperty(String key, String value)
: 儲存一對屬性。
public String getProperty(String key)
:使用此屬性列表中指定的鍵搜尋屬性值。public Set<String> 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
小貼士:文字中的資料,必須是鍵值對形式,可以使用空格、等號、冒號等符號分隔。
第九章 緩衝流
上面學習了基本的一些流,作為IO流的入門,接下來我們要見識一些更強大的流。比如能夠高效讀寫的緩衝流,能夠轉換編碼的轉換流,能夠持久化儲存物件的序列化流等等。這些功能更為強大的流,都是在基本的流物件基礎之上建立而來的,就像穿上鎧甲的武士一樣,相當於是對基本流物件的一種增強。
9.1 概述
緩衝流,也叫高效流,是對4個基本的FileXxx
流的增強,所以也是4個流,按照資料型別分類:
- 位元組緩衝流:
BufferedInputStream
,BufferedOutputStream
- 字元緩衝流:
BufferedReader
,BufferedWriter
緩衝流的基本原理,是在建立流物件時,會建立一個內建的預設大小的緩衝區陣列,通過緩衝區讀寫,減少系統IO次數,從而提高讀寫的效率。
9.2 位元組緩衝流
構造方法
public BufferedInputStream(InputStream in)
:建立一個 新的緩衝輸入流。public BufferedOutputStream(OutputStream out)
: 建立一個新的緩衝輸出流。
構造舉例,程式碼如下:
// 建立位元組緩衝輸入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 建立位元組緩衝輸出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
效率測試
查詢API,緩衝流讀寫方法與基本的流是一致的,我們通過複製大檔案(375MB),測試它的效率。
- 基本流,程式碼如下:
public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 記錄開始時間
long start = System.currentTimeMillis();
// 建立流物件
try (
FileInputStream fis = new FileInputStream("jdk9.exe");
FileOutputStream fos = new FileOutputStream("copy.exe")
){
// 讀寫資料
int b;
while ((b = fis.read()) != -1) {
fos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
// 記錄結束時間
long end = System.currentTimeMillis();
System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
}
}
十幾分鍾過去了...
- 緩衝流,程式碼如下:
public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 記錄開始時間
long start = System.currentTimeMillis();
// 建立流物件
try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
){
// 讀寫資料
int b;
while ((b = bis.read()) != -1) {
bos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
// 記錄結束時間
long end = System.currentTimeMillis();
System.out.println("緩衝流複製時間:"+(end - start)+" 毫秒");
}
}
緩衝流複製時間:8016 毫秒
如何更快呢?
使用陣列的方式,程式碼如下:
public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 記錄開始時間
long start = System.currentTimeMillis();
// 建立流物件
try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
){
// 讀寫資料
int len;
byte[] bytes = new byte[8*1024];
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0 , len);
}
} catch (IOException e) {
e.printStackTrace();
}
// 記錄結束時間
long end = System.currentTimeMillis();
System.out.println("緩衝流使用陣列複製時間:"+(end - start)+" 毫秒");
}
}
緩衝流使用陣列複製時間:666 毫秒
9.3 字元緩衝流
構造方法
public BufferedReader(Reader in)
:建立一個 新的緩衝輸入流。public BufferedWriter(Writer out)
: 建立一個新的緩衝輸出流。
構造舉例,程式碼如下:
// 建立字元緩衝輸入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 建立字元緩衝輸出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
特有方法
字元緩衝流的基本方法與普通字元流呼叫方式一致,不再闡述,我們來看它們具備的特有方法。
- BufferedReader:
public String readLine()
: 讀一行文字。 - BufferedWriter:
public void newLine()
: 寫一行行分隔符,由系統屬性定義符號。
readLine
方法演示,程式碼如下:
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// 建立流物件
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定義字串,儲存讀取的一行文字
String line = null;
// 迴圈讀取,讀取到最後返回null
while ((line = br.readLine())!=null) {
System.out.print(line);
System.out.println("------");
}
// 釋放資源
br.close();
}
}
newLine
方法演示,程式碼如下:
public class BufferedWriterDemo throws IOException {
public static void main(String[] args) throws IOException {
// 建立流物件
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 寫出資料
bw.write("JAVA");
// 寫出換行
bw.newLine();
bw.write("程式");
bw.newLine();
bw.write("員");
bw.newLine();
// 釋放資源
bw.close();
}
}
輸出效果:
JAVA
程式
員
9.4 練習:文字排序
請將文字資訊恢復順序。
3.侍中、侍郎郭攸之、費禕、董允等,此皆良實,志慮忠純,是以先帝簡拔以遺陛下。愚以為宮中之事,事無大小,悉以諮之,然後施行,必得裨補闕漏,有所廣益。
8.願陛下託臣以討賊興復之效,不效,則治臣之罪,以告先帝之靈。若無興德之言,則責攸之、禕、允等之慢,以彰其咎;陛下亦宜自謀,以諮諏善道,察納雅言,深追先帝遺詔,臣不勝受恩感激。
4.將軍向寵,性行淑均,曉暢軍事,試用之於昔日,先帝稱之曰能,是以眾議舉寵為督。愚以為營中之事,悉以諮之,必能使行陣和睦,優劣得所。
2.宮中府中,俱為一體,陟罰臧否,不宜異同。若有作奸犯科及為忠善者,宜付有司論其刑賞,以昭陛下平明之理,不宜偏私,使內外異法也。
1.先帝創業未半而中道崩殂,今天下三分,益州疲弊,此誠危急存亡之秋也。然侍衛之臣不懈於內,忠志之士忘身於外者,蓋追先帝之殊遇,欲報之於陛下也。誠宜開張聖聽,以光先帝遺德,恢弘志士之氣,不宜妄自菲薄,引喻失義,以塞忠諫之路也。
9.今當遠離,臨表涕零,不知所言。
6.臣本布衣,躬耕於南陽,苟全性命於亂世,不求聞達於諸侯。先帝不以臣卑鄙,猥自枉屈,三顧臣於草廬之中,諮臣以當世之事,由是感激,遂許先帝以驅馳。後值傾覆,受任於敗軍之際,奉命於危難之間,爾來二十有一年矣。
7.先帝知臣謹慎,故臨崩寄臣以大事也。受命以來,夙夜憂嘆,恐付託不效,以傷先帝之明,故五月渡瀘,深入不毛。今南方已定,兵甲已足,當獎率三軍,北定中原,庶竭駑鈍,攘除奸凶,興復漢室,還於舊都。此臣所以報先帝而忠陛下之職分也。至於斟酌損益,進盡忠言,則攸之、禕、允之任也。
5.親賢臣,遠小人,此先漢所以興隆也;親小人,遠賢臣,此後漢所以傾頹也。先帝在時,每與臣論此事,未嘗不嘆息痛恨於桓、靈也。侍中、尚書、長史、參軍,此悉貞良死節之臣,願陛下親之信之,則漢室之隆,可計日而待也。
案例分析
- 逐行讀取文字資訊。
- 解析文字資訊到集合中。
- 遍歷集合,按順序