六、Java中常用的API(通过包进行分类)————File类、IO流
一、util工具包下的補充類
介紹io包之前，先補充介紹幾個常用的工具類
1.Scanner類
-
什么是Scanner類
Scanner sc = new Scanner(System.in); int i = sc.nextInt();
一個可以解析基本類型和字符串的簡單文本掃描器。 例如，以下代碼使用戶能夠從 System.in 中讀取一個數：備注：System.in 系統輸入指的是通過鍵盤錄入數據。
-
Scanner使用步驟
public class TestDemo {public static void main(String[] args) {//創建鍵盤錄入數據的對象Scanner sc = new Scanner(System.in);System.out.println("請輸入一個整數：");//接收數據int i = sc.nextInt();// 輸出錄入的數據System.out.println("i:"+i);} }
1.查看類
?java.util.Scanner ：該類需要import導入后使用。
2.查看構造方法
?public Scanner(InputStream source) : 構造一個新的 Scanner ，它生成的值是從指定的輸入流掃描的。
3.查看成員方法
?public int nextInt() ：將輸入信息的下一個標記掃描為一個 int 值。結果如下：
2.java.util.Random類
-
什么是Random類
此類的實例用于生成偽隨機數。 -
Random使用步驟
使用Random類，完成生成3個10以內的隨機整數的操作，代碼如下： //1. 導包 import java.util.Random; public class Demo01_Random {public static void main(String[] args) {//2. 創建鍵盤錄入數據的對象Random r = new Random();for(int i = 0; i < 3; i++){//3. 隨機生成一個數據int number = r.nextInt(10);//4. 輸出數據System.out.println("number:"+ number);}} }
1.查看類
?java.util.Random ：該類需要 import導入使后使用。
2.查看構造方法
?public Random() ：創建一個新的隨機數生成器。
3.查看成員方法
?public int nextInt(int n) ：返回一個偽隨機數，范圍在 0 （包括）和 指定值 n （不包括）之間的int 值。備注：創建一個 Random 對象，每次調用 nextInt() 方法，都會生成一個隨機數。
二、java.io.File類
1. 概述
java.io.File 類是文件和目錄路徑名的抽象表示，主要用于文件和目錄的創建、查找和刪除等操作。
2.構造方法
-
public File(String pathname)：通過將給定的路徑名字符串轉換為抽象路徑名來創建新的 File實例。
-
public File(String parent, String child)：從父路徑名字符串和子路徑名字符串創建新的 File實例。
-
public File(File parent, String child)：從父抽象路徑名和子路徑名字符串創建新的 File實例。
public class TestDemo {public static void main(String[] args) {System.out.println("---------------------public File(String pathname)-------------------------------");//文件路徑名File file1 = new File("E:\\c.txt");System.out.println(file1);System.out.println("---------------------public File(String parent, String child)-------------------");// 通過父路徑和子路徑字符串File file2 = new File("E:\\", "c.txt");System.out.println(file2);File file3 = new File("E:\\aa", "c.txt");System.out.println(file3);System.out.println("---------------------public File(File parent, String child) -------------------");// 通過父級File對象和子路徑字符串File file = new File("E:\\aa");System.out.println(file);File file4 = new File(file, "c.txt");System.out.println(file4);} }結果如下：
注意
- 一個File對象代表硬盤中實際存在的一個文件或者目錄。
- 無論該路徑下是否存在文件或者目錄，都不影響File對象的創建。
3.常用方法
⑴獲取功能的方法
-
public String getAbsolutePath()：返回此File的絕對路徑名字符串。
-
public String getPath() ：將此File轉換為路徑名字符串。
-
public String getName() ：返回由此File表示的文件或目錄的名稱。
-
public long length() ：返回由此File表示的文件的長度。
public class TestDemo {public static void main(String[] args) {//現在項目的根目錄下創建文件aa/bb/cc.txtFile file = new File("aa/bb/cc.txt");//cc.txt的相對路徑System.out.println("文件的絕對路徑"+file.getAbsolutePath());System.out.println("文件的構造路徑"+file.getPath());//相對路徑System.out.println("文件的名稱："+file.getName());System.out.println("文件的長度："+file.length());System.out.println("-----------------------------------------------------");File f = new File("aa/bb");System.out.println("目錄的絕對路徑"+f.getAbsolutePath());System.out.println("目錄的構造路徑"+f.getPath());//相對路徑System.out.println("目錄的名稱："+f.getName());System.out.println("目錄的長度："+f.length());} }文件結構：
結果：
length()，表示文件的長度。但是File對象表示目錄，則返回值未指定。
⑵判斷功能的方法
-
public boolean exists() ：此File表示的文件或目錄是否實際存在。
-
public boolean isDirectory() ：此File表示的是否為目錄。
-
public boolean isFile()：此File表示的是否為文件。
public class TestDemo {public static void main(String[] args) {//現在項目的根目錄下創建文件aa/bb/cc.txtFile file = new File("aa/bb/cc.txt");//cc.txt的相對路徑File f = new File("E:/project/kejizheantan/aa/bb");//絕對路徑System.out.println("判斷文件是否存在："+file.exists());System.out.println("判斷文件夾是否存在："+f.exists());System.out.println("判斷是否是文件："+file.isFile());System.out.println("判斷是否是文件夾："+file.isDirectory());System.out.println("判斷是否是文件夾："+f.isDirectory());} }文件結構如下：
結果如下：
⑶創建和刪除功能的方法
-
public boolean createNewFile() ：當且僅當具有該名稱的文件尚不存在時，創建一個新的空文件。
-
public boolean delete() ：刪除由此File表示的文件或目錄。
-
public boolean mkdir() ：創建由此File表示的目錄。
-
public boolean mkdirs()：創建由此File表示的目錄，包括任何必需但不存在的父目錄。
public class TestDemo {public static void main(String[] args) {try {//文件的創建File wj = new File("java.txt");System.out.println("文件是否存在："+wj.exists());boolean flag1 = wj.createNewFile();System.out.println("是否創建成功："+flag1);System.out.println("文件是否存在："+wj.exists());//單級目錄的創建File f = new File("newdir");System.out.println("文件是否存在："+f.exists());boolean flag2 = f.mkdir();System.out.println("文件夾是否創建成功："+flag2);System.out.println("文件是否存在："+f.exists());//多級目錄創建File fi = new File("aa/bb/cc");System.out.println("文件是否存在："+fi.exists());System.out.println("文件夾是否存在："+fi.mkdir());//falseboolean flag3 = fi.mkdirs();System.out.println("文件夾是否創建成功："+flag3);System.out.println("文件是否存在："+fi.exists());//文件刪除File delfile = new File("java.txt");boolean flag4 = delfile.delete();System.out.println("文件是否刪除成功："+flag4);//單級文件夾刪除File f2 = new File("newdir");boolean flag5 = f2.delete();System.out.println("單級文件夾是否刪除成功："+flag5);//多級文件夾刪除File fi2 = new File("aa/bb/cc");boolean flag6 = fi2.delete();System.out.println("多級文件夾是否刪除成功："+flag6);} catch (IOException e) {e.printStackTrace();}} }注意：delete方法，如果此File表示目錄，則目錄必須為空才能刪除。
4.目錄的遍歷
-
public String[] list()：返回一個String數組，表示該File目錄中的所有子文件或目錄。
-
public File[] listFiles()：返回一個File數組，表示該File目錄中的所有的子文件或目錄。
public class TestDemo {public static void main(String[] args) {File dir = new File("aa");System.out.println("dir目錄的絕對路徑"+dir.getAbsolutePath());//通過public String[] list()獲取當前目錄下的文件以及文件夾的名稱。String[] list = dir.list();for (String s : list) {System.out.println(s);}//通過public File[] listFiles()獲取當前目錄下的文件以及文件夾對象，只要拿到了文件對象，那么就可以獲取更多信息File[] files = dir.listFiles();for (File file : files) {System.out.println(file);}} }目錄結構如下：
輸出結果如下：
注意： 調用listFiles方法的File對象，表示的必須是實際存在的目錄，否則返回null，無法進行遍歷。
5.通過遞歸遍歷文件目錄
⑴遞歸的概述
-
遞歸：指在當前方法內調用自己的這種現象。
-
遞歸的分類:
遞歸分為兩種，直接遞歸和間接遞歸。
?直接遞歸稱為方法自身調用自己。
?間接遞歸可以A方法調用B方法，B方法調用C方法，C方法調用A方法。 -
注意事項：
public class TestDemo {public static void main(String[] args) {//a();//b(1);}/** 1.遞歸一定要有條件限定，保證遞歸能夠停止下來，否則會發生棧內存溢出。 Exception in thread "main"* java.lang.StackOverflowError*/private static void a() {System.out.println("a方法");a();}/** 2.在遞歸中雖然有限定條件，但是遞歸次數不能太多。否則也會發生棧內存溢出。* Exception in thread "main" java.lang.StackOverflowError*/private static void b(int i) {System.out.println(i);//添加一個遞歸結束的條件,i==5000的時候結束if(i==50000){return;//結束方法}b(++i);}/** 3.構造方法,禁止遞歸* 編譯報錯:構造方法是創建對象使用的,不能讓對象一直創建下去*/public TestDemo() {//TestDemo();} }
① 遞歸一定要有條件限定，保證遞歸能夠停止下來，否則會發生棧內存溢出。
② 在遞歸中雖然有限定條件，但是遞歸次數不能太多。否則也會發生棧內存溢出。
③ 構造方法,禁止遞歸
⑵ 遞歸累加求和
計算1 ~ n的和
分析：num的累和 = num + (num-1)的累和，所以可以把累和的操作定義成一個方法，遞歸調用
代碼執行圖解
遞歸一定要有條件限定，保證遞歸能夠停止下來，次數不要太多，否則會發生棧內存溢出。
⑶遞歸求階乘
-
階乘：所有小于及等于該數的正整數的積。
n的階乘：n! = n * (n‐1) … 3 * 2 * 1
分析：這與累和類似,只不過換成了乘法運算，學員可以自己練習，需要注意階乘值符合int類型的范圍。
推理得出：n! = n * (n‐1)!
代碼實現：
public class TestDemo {//計算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的階乘為1if (n == 1) {return 1;}/*n不為1時,方法返回 n! = n*(n‐1)!遞歸調用getValue方法*/return n * getValue(n - 1);} }
⑷遞歸打印多級目錄
分析：多級目錄的打印，就是當目錄的嵌套。遍歷之前，無從知道到底有多少級目錄，所以我們還是要使用遞歸實現。
代碼如下：
目錄結構如下：
結果如下：
6.綜合案例
⑴文件搜索
搜索aa相對路徑中的 .java和 .JAVA 文件。
分析：
- 目錄搜索，無法判斷多少級目錄，所以使用遞歸，遍歷所有目錄。
- 遍歷目錄時，獲取的子文件，通過文件名稱，判斷是否符合條件。
代碼如下：
public class TestDemo {public static void main(String[] args) {// 創建File對象File dir = new File("aa");// 調用打印目錄方法printDir(dir);}public static void printDir(File dir) {// 獲取子文件和目錄File[] files = dir.listFiles();// 循環打印for (File file : files) {if (file.isFile()) {// 是文件，判斷文件名并輸出文件絕對路徑if (file.getName().toLowerCase().endsWith(".java")) {System.out.println("文件名:" + file.getAbsolutePath());}} else {// 是目錄，繼續遍歷,形成遞歸printDir(file);}}} }目錄結構如下：
打印結果如下：
⑵文件過濾器優化文件搜索功能
java.io.FileFilter 是一個接口，是File的過濾器。 該接口的對象可以傳遞給File類的 listFiles(FileFilter)作為參數， 接口中只有一個方法。
boolean accept(File pathname) ：測試pathname是否應該包含在當前File目錄中，符合則返回true。
分析：
- ①接口作為參數，需要傳遞子類對象，重寫其中方法。我們選擇匿名內部類方式，比較簡單。
- ②accept 方法，參數為File，表示當前File下所有的子文件和子目錄。保留住則返回true，過濾掉則返回false。保留規則：
??a.要么是.java文件。
??b.要么是目錄，用于繼續遍歷。 - ③通過過濾器的作用， listFiles(FileFilter) 返回的數組元素中，子文件對象都是符合條件的，可以直接打印。
代碼實現：
public class TestDemo {public static void main(String[] args) {// 創建File對象File dir = new File("aa");// 調用打印目錄方法printDir(dir);}public static void printDir(File dir) {// 匿名內部類方式,創建過濾器子類對象File[] files = dir.listFiles(new FileFilter() {//accept 方法，參數為File，表示當前File下所有的子文件和子目錄。保留住則返回true，過濾掉則返回false@Overridepublic boolean accept(File pathname) {//測試pathname是否應該包含在當前File目錄中，符合則返回true。//表示當前File下所有的子文件和子目錄。保留住則返回true，過濾掉則返回// 注意：得加pathname.isDirectory()判斷，因為第一次傳過來的是aa目錄，如果不加直接導致aa文件夾被過濾掉了，導致aa目錄下的子文件遍歷不到return pathname.getName().toLowerCase().endsWith(".java") || pathname.isDirectory();}});// 循環打印for (File file : files) {if (file.isFile()) {System.out.println("文件名:" + file.getAbsolutePath());} else {printDir(file);}}} }目錄結構：
結果如下：
使用lambda優化代碼：
分析： FileFilter 是只有一個方法的接口，因此可以用lambda表達式簡寫。
lambda格式：
()‐>{ }
public class TestDemo {public static void main(String[] args) {// 創建File對象File dir = new File("aa");// 調用打印目錄方法printDir(dir);}public static void printDir(File dir) {// 匿名內部類方式,創建過濾器子類對象/*File[] files = dir.listFiles(new FileFilter() {//accept 方法，參數為File，表示當前File下所有的子文件和子目錄。保留住則返回true，過濾掉則返回false@Overridepublic boolean accept(File pathname) {//測試pathname是否應該包含在當前File目錄中，符合則返回true。//表示當前File下所有的子文件和子目錄。保留住則返回true，過濾掉則返回//注意：得加pathname.isDirectory()判斷，因為第一次傳過來的是aa目錄，如果不加直接導致aa文件夾被過濾掉了，導致aa目錄下的子文件遍歷不到return pathname.getName().toLowerCase().endsWith(".java") || pathname.isDirectory();}});*/File[] files = dir.listFiles(f -> f.getName().toLowerCase().endsWith(".java") || f.isDirectory());// 循環打印for (File file : files) {if (file.isFile()) {System.out.println("文件名:" + file.getAbsolutePath());} else {printDir(file);}}} }三、I/O流
Java中I/O操作主要是指使用 java.io 包下的內容，進行輸入、輸出操作。輸入也叫做讀取數據，輸出也叫做作寫出數據。
1.I/O流的分類
根據數據的流向分為：輸入流和輸出流。
- 輸入流 ：把數據從 其他設備 上讀取到 內存 中的流。
- 輸出流 ：把數據從 內存 中寫出到 其他設備 上的流。
格局數據的類型分為：字節流和字符流。
- 字節流 ：以字節為單位，讀寫數據的流。
- 字符流 ：以字符為單位，讀寫數據的流。
常用I/O流的結構
2.I/O流的頂級父類
3.字節流
一切皆為字節
一切文件數據(文本、圖片、視頻等)在存儲時，都是以二進制數字的形式保存，都一個一個的字節，那么傳輸時一樣如此。所以，字節流可以傳輸任意文件數據。在操作流的時候，我們要時刻明確，無論使用什么樣的流對象，底層傳輸的始終為二進制數據。
⑴字節輸出流【java.io.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方法，當完成流的操作時，必須調用此方法，釋放系統資源。
①java.io.FileOutputStream 類
OutputStream 有很多子類，我們從最簡單的一個子類開始。
java.io.FileOutputStream類是文件輸出流，用于將數據寫出到文件。
構造方法
- public FileOutputStream(File file)：創建一個向指定 File 對象表示的文件中寫入數據的文件輸出流。
- public FileOutputStream(String name) ： 創建一個向具有指定名稱的文件中寫入數據的輸出文件流。
當你創建一個流對象時，必須傳入一個文件路徑。該路徑下，如果沒有這個文件，會創建該文件。如果有這個文件，會清空這個文件的數據。（文件夾的路徑必須存在，該構造方法是無法創建文件夾的）
代碼如下：
結果如下：
寫出字節數據
- write(int b) 方法，每次可以寫出一個字節數據
- write(byte[] b) ，每次可以寫出數組中的數據
- write(byte[] b, int off, int len)每次寫出從off索引開始，len個字節
代碼如下：
public class TestDemo {public static void main(String[] args) {try {//使用文件對象創建流對象File file = new File("d:\\aaa.txt");FileOutputStream fos1 = new FileOutputStream(file);//寫出數據fos1.write(97); // 寫出第1個字節fos1.write(98); // 寫出第2個字節fos1.write(99); // 寫出第3個字節//使用文件名稱創建流對象FileOutputStream fos2 = new FileOutputStream("d:\\bbb.txt");//將字符串轉換成字節數組byte[] bytes = "柯基偵探".getBytes();//寫出字節數組fos2.write(bytes);//使用文件名稱創建流對象FileOutputStream fos3 = new FileOutputStream("d:\\ccc.txt");//將字符串轉換成字節數組byte[] bytes2 = "abcdefg".getBytes();// 寫出從索引2開始，2個字節。索引2是c，兩個字節，也就是cd。fos3.write(bytes2,2,2);//一定最后要關閉資源fos1.close();fos2.close();fos3.close();} catch (Exception e) {e.printStackTrace();}} }文件中的結果如下：
注意：
- 雖然參數為int類型四個字節，但是只會保留一個字節的信息寫出。
- 流操作完畢后，必須釋放系統資源，調用close方法，千萬記得。
數據追加續寫
經過以上的演示，每次程序運行，創建輸出流對象，都會清空目標文件中的數據。如何保留目標文件中數據，還能繼續添加新數據呢？
- public FileOutputStream(File file, boolean append)： 創建一個向指定 File 對象表示的文件中寫入數據的文件輸出流。
- public FileOutputStream(String name, boolean append) ：創建一個向具有指定 name 的文件中寫入數據的輸出文件流。
這兩個構造方法，參數中都需要傳入一個boolean類型的值， true 表示追加數據， false 表示清空原有數據。這樣創建的輸出流對象，就可以指定是否追加續寫了。
代碼使用演示：
結果如下：
寫出換行
Windows系統里，換行符號是 \r\n 。把
以指定是否追加續寫了。
代碼使用演示：
輸出的結果：
回車符 \r 和換行符 \n ：
- 回車符：回到一行的開頭（return）。
- 換行符：下一行（newline）。
系統中的換行：
- Windows系統里，每行結尾是 回車+換行 ，即 \r\n ；
- Unix系統里，每行結尾只有 換行 ，即 \n ；
- Mac系統里，每行結尾是 回車 ，即 \r 。從 Mac OS X開始與Linux統一。
系統中的文件分隔符：
- windows中是“\”
- linux中是“/”
因為linux和windows存在差異，所以分割符用File.separator顯示
⑵字節輸入流【java.io.InputStream】
java.io.InputStream 抽象類是表示字節輸入流的所有類的超類，可以讀取字節信息到內存中。它定義了字節輸入流的基本共性功能方法。
- public void close() ：關閉此輸入流并釋放與此流相關聯的任何系統資源。
- public abstract int read() ： 從輸入流讀取數據的下一個字節。
- public int read(byte[] b) ： 從輸入流中讀取一些字節數，并將它們存儲到字節數組 b中 。
注意：
close方法，當完成流的操作時，必須調用此方法，釋放系統資源。
① java.io.FileInputStream類
java.io.FileInputStream類是文件輸入流，從文件中讀取字節。
構造方法
- FileInputStream(File file) ： 通過打開與實際文件的連接來創建一個 FileInputStream ，該文件由文件系統中的 File對象 file命名。
- FileInputStream(String name) ： 通過打開與實際文件的連接來創建一個 FileInputStream ，該文件由文件系統中的路徑名 name命名。
當你創建一個流對象時，必須傳入一個文件路徑。該路徑下，如果沒有該文件,會拋出FileNotFoundException 。
public class TestDemo {public static void main(String[] args) {try {// 使用文件名稱創建流對象FileInputStream fis = new FileInputStream("aa" + File.separator + "aaa.JAVA");// 使用File對象創建流對象File file = new File("aa" + File.separator + "cc" + File.separator + "aaa.java");FileInputStream fis2 = new FileInputStream(file);} catch (FileNotFoundException e) {e.printStackTrace();}} }讀取字節數據方法
-
int read() 方法，每次可以讀取一個字節的數據，提升為int類型，讀取到文件末尾，返回 -1 。
-
int read(byte[] b)每次讀取b的長度個字節到數組中，返回讀取到的有效字節個數，讀
取到末尾時，返回 -1 -
代碼演示如下：
public class TestDemo {public static void main(String[] args) {try {// 使用文件名稱創建流對象FileInputStream fis = new FileInputStream("aa/aaa.txt");// 文件中為abcSystem.out.println("-------------普通方式讀取數據--------------");// 讀取數據，返回一個字節,并且沒讀取一個下標移動一位，雖然讀取了一個字節，但是會自動提升為int類型。System.out.println(fis.read());//97System.out.println(fis.read());//98System.out.println(fis.read());//99System.out.println(fis.read());//-1/讀到文件末尾返回-1System.out.println("-----------循環讀取文件中的數據------------");// 使用文件名稱創建流對象.FileInputStream fis2 = new FileInputStream("aa/aaa.txt");// 文件中為abc//自定義一個變量，用于接受讀取到的數據int b;//循環讀取，將讀取到的數據存儲到變量中while((b = fis2.read()) != -1){System.out.println((char) b);}System.out.println("----------通過字節數組讀取文件中的數據-------");// 使用文件名稱創建流對象.FileInputStream fis3 = new FileInputStream("aa/aaa.txt");// 文件中為abc//定義一個變量，用于記錄每次讀取到的有效個數int c;//定義一個字節數組，用于緩存每次讀取到的字節byte[] bytes = new byte[2];// 循環讀取,將讀取到的數據緩存到字節數組中while((c = fis3.read(bytes)) != -1){// 每次讀取后,把數組變成字符串打印System.out.println(new String(bytes));}//關閉資源fis.close();fis2.close();fis3.close();} catch (Exception e) {e.printStackTrace();}} } -
項目結構如下：
- 結果如下：
- 字節讀取文件的原理：
- 結果如下：
字節數組讀取數據問題分析：
錯誤數據 b ，是由于最后一次讀取時，只讀取一個字節 c ，數組中，上次讀取的數據沒有被完全替換，所以要通過 len ，獲取有效的字節。
正確的代碼如下：
public class IOTest {public static void main(String[] args) {try {// 使用文件名稱創建流對象.FileInputStream fis = new FileInputStream("aa/aaa.txt");// 文件中為abc//定義一個變量，用于記錄每次讀取到的有效個數int len;//定義一個字節數組，用于緩存每次讀取到的字節byte[] bytes = new byte[2];// 循環讀取,將讀取到的數據緩存到字節數組中while((len = fis.read(bytes)) != -1){// 每次讀取后,把數組的有效字節部分，變成字符串打印System.out.println(new String(bytes,0,len));//len 每次讀取的有效字節個數}//關閉資源fis.close();} catch (Exception e) {e.printStackTrace();}} }結果如下：
注意
??①使用數組讀取，每次讀取多個字節，減少了系統間的IO操作次數，從而提高了讀寫的效率，建議開發中使用。
??② 流操作完畢后，必須釋放系統資源，調用close方法，千萬記得。
4.字節流的綜合案例：圖片復制
代碼演示如下：
項目結構如下：
結果如下：
注意：
流的關閉原則：先開后關，后開先關。
5.字符流
先來看一段代碼：
public class IOTest {public static void main(String[] args) {try {FileInputStream fis = new FileInputStream("aa/aaa.txt");//文件內容:柯基偵探byte[] bytes = new byte[5];int len;while ((len = fis.read(bytes)) != -1){System.out.println(new String(bytes,0,len));}} catch (Exception e) {e.printStackTrace();}} }結果：
當使用字節流讀取文本文件時，可能會有一個小問題。就是遇到中文字符時，可能不會顯示完整的字符，那是因為一個中文字符可能占用多個字節存儲。所以Java提供一些字符流類，以字符為單位讀寫數據，專門用于處理文本文件。
⑴ 字符輸入流【Reader】
java.io.Reader 抽象類是表示用于讀取字符流的所有類的超類，可以讀取字符信息到內存中。它定義了字符輸入流的基本共性功能方法。
- public void close() ：關閉此流并釋放與此流相關聯的任何系統資源。
- public int read() ： 從輸入流讀取一個字符。
- public int read(char[] cbuf)： 從輸入流中讀取一些字符，并將它們存儲到字符數組 cbuf中 。
⑵FileReader類
java.io.FileReader 類是讀取字符文件的便利類。構造時使用系統默認的字符編碼和默認字節緩沖區。
- 字符編碼：字節與字符的對應規則。Windows系統的中文編碼默認是GBK編碼表。
idea中UTF-8 - 字節緩沖區：一個字符數組，用來臨時存儲字節數據。
構造方法
- FileReader(File file) ： 創建一個新的 FileReader ，給定要讀取的File對象。
- FileReader(String fileName) ： 創建一個新的 FileReader ，給定要讀取的文件的名稱。
當你創建一個流對象時，必須傳入一個文件路徑。類似于FileInputStream 。
構造舉例，代碼如下：
public class IOTest {public static void main(String[] args) {try {// 使用File對象創建流對象File file = new File("aa/aaa.txt");FileReader fileReader = new FileReader(file);// 使用文件名稱創建流對象FileReader fileReader1 = new FileReader("aa/aaa.txt");} catch (Exception e) {e.printStackTrace();}} }讀取字符數據
- public int read() 讀取字符每次可以讀取一個字符的數據，提升為int類型，讀取到文件末尾，返回 -1
- public int read(char[] cbuf). 使用字符數組讀取,每次讀取b的長度個字符到數組中，返回讀取到的有效字符個數，讀取到末尾時，返回 -1
代碼如下：
public class IOTest {public static void main(String[] args) {try {// 使用文件名稱創建流對象FileReader fr = new FileReader("aa/aaa.txt");//文件中的內容是漢字：柯基偵探System.out.println("-------------普通方式讀取數據--------------");// 讀取數據，返回一個字符,并且沒讀取一個下標移動一位，雖然讀取了一個字符，但是會自動提升為int類型。System.out.println( fr.read());//26607System.out.println( fr.read());//22522System.out.println(fr.read());//20390System.out.println(fr.read());//25506System.out.println(fr.read());//-1/讀到文件末尾返回-1System.out.println("-----------循環讀取文件中的數據------------");FileReader fr2 = new FileReader("aa/aaa.txt");//文件中的內容是漢字：柯基偵探//自定義一個變量，用于接受讀取到的數據int b;//循環讀取，將讀取到的數據存儲到變量中while((b = fr2.read()) != -1){System.out.println((char) b);}System.out.println("-----------通過字符數組讀取文件中的數據------------");FileReader fr3 = new FileReader("aa/aaa.txt");//文件中的內容是漢字：柯基偵探//定義一個變量，用于記錄每次讀取到的有效個數int c;//定義一個字節數組，用于緩存每次讀取到的字節char[] chars = new char[3];// 循環讀取,將讀取到的數據緩存到字節數組中while((c = fr3.read(chars)) != -1){System.out.println(new String(chars));}System.out.println("-----------通過字符數組讀取文件中的數據改進版------------");FileReader fr4 = new FileReader("aa/aaa.txt");//文件中的內容是漢字：柯基偵探//定義一個變量，用于記錄每次讀取到的有效個數int d;//定義一個字節數組，用于緩存每次讀取到的字節char[] cs = new char[3];// 循環讀取,將讀取到的數據緩存到字節數組中while((d = fr4.read(cs)) != -1){System.out.println(new String(cs,0,d));}//關閉資源fr.close();fr2.close();fr3.close();fr4.close();} catch (Exception e) {e.printStackTrace();}} }結果如下：
⑶字符輸出流【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() 關閉此流，但要先刷新它。
⑷FileWriter類
java.io.FileWriter 類是寫出字符到文件的便利類。構造時使用系統默認的字符編碼和默認字節緩沖區
構造方法
- FileWriter(File file) ： 創建一個新的 FileWriter，給定要讀取的File對象。
- FileWriter(String fileName) ： 創建一個新的 FileWriter，給定要讀取的文件的名稱。
當你創建一個流對象時，必須傳入一個文件路徑，類似于FileOutputStream。
構造舉例，代碼如下：
public class IOTest {public static void main(String[] args) {try {// 使用文件名稱創建流對象FileWriter fw = new FileWriter("aa/aaa.txt");// 使用File對象創建流對象File file = new File("aa/aaa.txt");FileWriter fileWriter = new FileWriter(file);} catch (Exception e) {e.printStackTrace();}} }基本寫出數據
-
public void write(int c) 寫出字符,每次可以寫出一個字符數據
public class IOTest {public static void main(String[] args) {try {// 使用文件名稱創建流對象FileWriter fw = new FileWriter("aa/aaa.txt");//寫出數據fw.write('柯');//寫出第一個字符fw.write('基');//寫出第二個字符fw.write('偵');//寫出第三個字符fw.write('探');//寫出第四份字符fw.write(97);//寫出第五個字符/*【注意】關閉資源時,與FileOutputStream不同。如果不關閉,數據只是保存到緩沖區，并未保存到文件。*/fw.close();} catch (Exception e) {e.printStackTrace();}} }結果如下：
關閉和刷新
因為內置緩沖區的原因，如果不關閉輸出流，無法寫出字符到文件中。但是關閉的流對象，是無法繼續寫出數據的。如果我們既想寫出數據，又想繼續使用流，就需要 flush 方法了。
- public void flush() ：刷新緩沖區，流對象可以繼續使用。
- public void close() :先刷新緩沖區，然后通知系統釋放資源。流對象不可以再被使用了。
代碼如下：
public class IOTest {public static void main(String[] args) {try {// 使用文件名稱創建流對象FileWriter fw = new FileWriter("aa/aaa.txt");// 寫出數據，通過flushfw.write('刷'); // 寫出第1個字符fw.flush();fw.write('新'); // 繼續寫出第2個字符，寫出成功fw.flush();// 寫出數據，通過closefw.write('關'); // 寫出第1個字符fw.close();fw.write('閉'); // 繼續寫出第2個字符,【報錯】java.io.IOException: Stream closedfw.close();} catch (Exception e) {e.printStackTrace();}} }結果如下：
注意：
即便是flush方法寫出了數據，操作的最后還是要調用close方法，釋放系統資源
寫出其他數據
- public void write(char[] cbuf) 寫出字符數組
- public void write(char[] cbuf,int off,int len) 寫出字符數組的某一部分。
- public void write(String str) 寫出字符串
- public void write(String str, int off,int len) 寫出字符串某一部分
代碼案例：
public class IOTest {public static void main(String[] args) {try {// 使用文件名稱創建流對象FileWriter fw = new FileWriter("aa/aaa.txt");System.out.println("-------------------寫出字符數組-----------------");// 字符串轉換為字節數組char[] chars = "柯基偵探".toCharArray();// 寫出字符數組fw.write(chars); // 柯基偵探// 寫出從索引2開始，2個字符。索引2是'偵'，兩個字節，也就是'偵探'。fw.write(chars,2,2); // 偵探// 刷新fw.flush();System.out.println("-------------------寫出字符串-----------------");// 字符串String msg = "微信公眾號";fw.write(msg); //微信公眾號// 寫出從索引2開始，2個字符。索引2是'公'，兩個字節，也就是'公眾'。fw.write(msg,2,2); // 公眾//刷新fw.flush();System.out.println("-------------------續寫和換行(操作類似于FileOutputStream。)-----------------");// 使用文件名稱創建流對象，可以續寫數據FileWriter fw2 = new FileWriter("aa/aaa.txt",true);// 寫出換行fw.write("\r\n");// 寫出字符串fw.write("柯基偵探");// 寫出換行fw.write("\r\n");// 寫出字符串fw.write("微信公眾號");fw.close();} catch (Exception e) {e.printStackTrace();}} }結果如下：
注意：
- 字符流，只能操作文本文件，不能操作圖片，視頻等非文本文件。
- 當我們單純讀或者寫文本文件時 使用字符流 其他情況使用字節流
6.緩沖流
⑴概述
緩沖流,也叫高效流，是對4個基本的 FileXxx 流的增強，所以也是4個流。
按照數據類型分類：
- 字節緩沖流： java.io.BufferedInputStream，java.io.BufferedOutputStream
- 字符緩沖流： java.io.BufferedReader， java.io.BufferedWriter
緩沖流的基本原理是在創建流對象時，會創建一個內置的默認大小的緩沖區數組，通過緩沖區讀寫，減少系統IO次數，從而提高讀寫的效率
緩沖流圖解：
⑵ 字節緩沖流
構造方法
- 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，緩沖流讀寫方法與基本的流是一致的，我們通過復制大文件（357 MB），測試它的效率。
-
使用基本流進行文件復制代碼如下：
public class BufferedDemo {public static void main(String[] args) {// 記錄開始時間long start = System.currentTimeMillis();// 創建流對象try (FileInputStream fis = new FileInputStream("aa/movie.mp4");FileOutputStream fos = new FileOutputStream("aa/copymovie.mp4")){// 讀寫數據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("aa/movie.mp4"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("aa/copymovie.mp4"));) {// 讀寫數據int b;while ((b = bis.read()) != -1) {bos.write(b);}} catch (IOException e) {e.printStackTrace();}// 記錄結束時間long end = System.currentTimeMillis();System.out.println("緩沖流復制時間:" + (end - start) + " 毫秒");} }緩緩沖流復制時間:18126 毫秒
-
如何更快呢？使用緩存流和數組的方式，代碼如下：
public class BufferedDemo {public static void main(String[] args) throws FileNotFoundException {// 記錄開始時間long start = System.currentTimeMillis();// 創建流對象try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("aa/movie.mp4"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("aa/copymovie.mp4"));){// 讀寫數據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)+" 毫秒");} }緩沖流結合數組復制時間:3464 毫秒
⑶字符緩沖流
構造方法
- public BufferedReader(Reader in) ：創建一個 新的緩沖輸入流。
- public BufferedWriter(Writer out) ： 創建一個新的緩沖輸出流。
特有方法
字符緩沖流的基本方法與普通字符流調用方式一致，不再闡述，我們來看它們具備的特有方法。
- public String readLine() : 讀一行文字。
- public void newLine() : 寫一行行分隔符,由系統屬性定義符號。
readLine 方法演示，代碼如下：
public class InputStreamReader {public static void main(String[] args) throws IOException {// 創建流對象BufferedReader br = new BufferedReader(new FileReader("aa/aaa.txt"));// 定義字符串,保存讀取的一行文字String line = null;// 循環讀取,讀取到最后返回nullwhile ((line = br.readLine()) != null) {System.out.print(line);System.out.println("‐‐‐‐‐‐");}// 釋放資源br.close();} }結果如下：
newLine 方法演示，代碼如下：
public class OutputStreamWriter {public static void main(String[] args) throws IOException {// 創建流對象BufferedWriter bw = new BufferedWriter(new FileWriter("aa/aaa.txt"));// 寫出數據bw.write("柯基");// 寫出換行bw.newLine();bw.write("偵探");bw.newLine();bw.write("微信公眾號");bw.newLine();// 釋放資源bw.close();} }結果如下：
⑷練習:文本排序
請將文本信息恢復順序。
3.侍中、侍郎郭攸之、費祎、董允等，此皆良實，志慮忠純，是以先帝簡拔以遺陛下。愚以為宮中之事，事無大小，悉以咨之，然后施行，必得裨補闕漏，有所廣益。
8.愿陛下托臣以討賊興復之效，不效，則治臣之罪，以告先帝之靈。若無興德之言，則責攸之、祎、允等之慢，以彰其咎；陛下亦宜自謀，以咨諏善道，察納雅言，深追先帝遺詔，臣不勝受恩感激。
4.將軍向寵，性行淑均，曉暢軍事，試用之于昔日，先帝稱之曰能，是以眾議舉寵為督。愚以為營中之事，悉以咨之，必能使行陣和睦，優劣得所。
2.宮中府中，俱為一體，陟罰臧否，不宜異同。若有作奸犯科及為忠善者，宜付有司論其刑賞，以昭陛下平明之理，不宜偏私，使內外異法也。
1.先帝創業未半而中道崩殂，今天下三分，益州疲弊，此誠危急存亡之秋也。然侍衛之臣不懈于內，忠志之士忘身于外者，蓋追先帝之殊遇，欲報之于陛下也。誠宜開張圣聽，以光先帝遺德，恢弘志士之氣，不宜妄自菲薄，引喻失義，以塞忠諫之路也。
9.今當遠離，臨表涕零，不知所言。
6.臣本布衣，躬耕于南陽，茍全性命于亂世，不求聞達于諸侯。先帝不以臣卑鄙，猥自枉屈，三顧臣于草廬之中，咨臣以當世之事，由是感激，遂許先帝以驅馳。后值傾覆，受任于敗軍之際，奉命于危難之間，爾來二十有一年矣。
7.先帝知臣謹慎，故臨崩寄臣以大事也。受命以來，夙夜憂嘆，恐付托不效，以傷先帝之明，故五月渡瀘，深入不毛。今南方已定，兵甲已足，當獎率三軍，北定中原，庶竭駑鈍，攘除奸兇，興復漢室，還于舊都。此臣所以報先帝而忠陛下之職分也。至于斟酌損益，進盡忠言，則攸之、祎、允之任也。
5.親賢臣，遠小人，此先漢所以興隆也；親小人，遠賢臣，此后漢所以傾頹也。先帝在時，每與臣論此事，未嘗不嘆息痛恨于桓、靈也。侍中、尚書、長史、參軍，此悉貞良死節之臣，愿陛下親之信之，則漢室之隆，可計日而待也。
案例分析
案例實現代碼如下
public class BufferedTest {public static void main(String[] args) throws IOException {// 創建map集合,保存文本數據,鍵為序號,值為文字HashMap<String, String> lineMap = new HashMap<>();// 創建流對象BufferedReader br = new BufferedReader(new FileReader("aa/in.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("aa/out.txt"));// 讀取數據String line = null;while ((line = br.readLine()) != null) {// 解析文本String[] split = line.split("\\.");// 保存到集合lineMap.put(split[0], split[1]);}// 釋放資源br.close();// 遍歷map集合for (int i = 1; i <= lineMap.size(); i++) {String key = String.valueOf(i);// 獲取map中文本String value = lineMap.get(key);// 寫出拼接文本bw.write(key + "." + value);// 寫出換行bw.newLine();}// 釋放資源bw.close();} }結果如下：
7.轉換流
⑴字符編碼和字符集
字符編碼
計算機中儲存的信息都是用二進制數表示的，而我們在屏幕上看到的數字、英文、標點符號、漢字等字符是二進制數轉換之后的結果。按照某種規則，將字符存儲到計算機中，稱為編碼 。反之，將存儲在計算機中的二進制數按照某種規則解析顯示出來，稱為解碼 。比如說，按照A規則存儲，同樣按照A規則解析，那么就能顯示正確的文本f符號。反之，按照A規則存儲，再按照B規則解析，就會導致亂碼現象。
- 字符編碼 Character Encoding : 就是一套自然語言的字符與二進制數之間的對應規則。
字符集
- 字符集 Charset ：也叫編碼表。是一個系統支持的所有字符的集合，包括各國家文字、標點符號、圖形符號、數字等。
計算機要準確的存儲和識別各種字符集符號，需要進行字符編碼，一套字符集必然至少有一套字符編碼。常見字符集有ASCII字符集、GBK字符集、Unicode字符集等。
可見，當指定了編碼，它所對應的字符集自然就指定了，所以編碼才是我們最終要關心的。
-
ASCII字符集 ：
-
ASCII（American Standard Code for Information Interchange，美國信息交換標準代碼）是基于拉丁字母的一套電腦編碼系統，用于顯示現代英語，主要包括控制字符（回車鍵、退格、換行鍵等）和可顯示字符（英文大小寫字符、阿拉伯數字和西文符號）。
-
基本的ASCII字符集，使用7位（bits）表示一個字符，共128字符。ASCII的擴展字符集使用8位（bits）表示一個字符，共256字符，方便支持歐洲常用字符。
-
ISO-8859-1字符集：
-
拉丁碼表，別名Latin-1，用于顯示歐洲使用的語言，包括荷蘭、丹麥、德語、意大利語、西班牙語等。
-
ISO-5559-1使用單字節編碼，兼容ASCII編碼。
-
GBxxx字符集
-
GB就是國標的意思，是為了顯示中文而設計的一套字符集。
-
GB2312：簡體中文碼表。一個小于127的字符的意義與原來相同。但兩個大于127的字符連在一起時，就表示一個漢字，這樣大約可以組合了包含7000多個簡體漢字，此外數學符號、羅馬希臘的字母、日文的假名們都編進去了，連在ASCII里本來就有的數字、標點、字母都統統重新編了兩個字節長的編碼，這就是常說的"全角"字符，而原來在127號以下的那些就叫"半角"字符了。
-
GBK：最常用的中文碼表。是在GB2312標準基礎上的擴展規范，使用了雙字節編碼方案，共收錄了21003個漢字，完全兼容GB2312標準，同時支持繁體漢字以及日韓漢字等。
-
GB18030：最新的中文碼表。收錄漢字70244個，采用多字節編碼，每個字可以由1個、2個或4個字節組成。支持中國國內少數民族的文字，同時支持繁體漢字以及日韓漢字等。
-
Unicode字符集 ：
- Unicode編碼系統為表達任意語言的任意字符而設計，是業界的一種標準，也稱為統一碼、標準萬國 碼。
- 它最多使用4個字節的數字來表達每個字母、符號，或者文字。有三種編碼方案，UTF-8、UTF-16和UTF32。最為常用的UTF-8編碼。
- UTF-8編碼，可以用來表示Unicode標準中任何字符，它是電子郵件、網頁及其他存儲或傳送文字的應用中，優先采用的編碼。互聯網工程工作小組（IETF）要求所有互聯網協議都必須支持UTF-8編碼。所以，我們開發Web應用，也要使用UTF-8編碼。它使用一至四個字節為每個字符編碼，編碼規則：
- 128個US-ASCII字符，只需一個字節編碼。
- 拉丁文等字符，需要二個字節編碼。
- 大部分常用字（含中文），使用三個字節編碼。
- 其他極少使用的Unicode輔助字符，使用四字節編碼。
⑵編碼引出的問題
在IDEA中，使用 FileReader 讀取項目中的文本文件。由于IDEA的設置，都是默認的 UTF-8 編碼，所以沒有任何問題。但是，當讀取Windows系統中創建的文本文件時，由于Windows系統的默認是GBK編碼，就會出現碼。
public class ReaderDemo {public static void main(String[] args) throws IOException {FileReader fileReader = new FileReader("aa/gbk.txt");int read;while ((read = fileReader.read()) != -1) {System.out.print((char) read);}fileReader.close();} }結果如下：
那么如何讀取GBK編碼的文件呢？
⑶ InputStreamReader類
轉換流 java.io.InputStreamReader ，是Reader的子類，是從字節流到字符流的橋梁。它讀取字節，并使用指定的字符集將其解碼為字符。它的字符集可以由名稱指定，也可以接受平臺的默認字符集。
構造方法
- InputStreamReader(InputStream in) : 創建一個使用默認字符集的字符流。
- InputStreamReader(InputStream in, String charsetName) : 創建一個指定字符集的字符流。
指定編碼讀取代碼案例如下：
public class ReaderDemo {public static void main(String[] args) throws IOException {// 定義文件路徑,文件為gbk編碼String FileName = "aa/gbk.txt";// 創建流對象,默認UTF8編碼InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));// 創建流對象,指定GBK編碼InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");// 定義變量,保存字符int read;// 使用默認編碼字符流讀取,亂碼while ((read = isr.read()) != -1) {System.out.print((char)read); // �?���??�?��?�}isr.close();//換行符System.out.println();// 使用指定編碼字符流讀取,正常解析while ((read = isr2.read()) != -1) {System.out.print((char)read);// 柯基偵探微信公眾號}isr2.close();} }結果如下：
⑷ OutputStreamWriter類
轉換流 java.io.OutputStreamWriter ，是Writer的子類，是從字符流到字節流的橋梁。使用指定的字符集將字符編碼為字節。它的字符集可以由名稱指定，也可以接受平臺的默認字符集。
構造方法
- OutputStreamWriter(OutputStream in) : 創建一個使用默認字符集的字符流。
- OutputStreamWriter(OutputStream in, String charsetName) : 創建一個指定字符集的字符流。
指定編碼寫出的代碼案例如下：
public class WriterDemo {public static void main(String[] args) throws IOException {// 定義文件路徑String FileName = "aa/utf8.txt";// 創建流對象,默認UTF8編碼OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));// 寫出數據osw.write("柯基偵探微信公眾號"); // 保存為6個字節osw.close();// 定義文件路徑String FileName2 = "aa/gbk.txt";// 創建流對象,指定GBK編碼OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2), "GBK");// 寫出數據osw2.write("柯基偵探微信公眾號");// 保存為4個字節osw2.close();} }結果如下：
轉換流理解圖解
⑸練習：轉換文件編碼
將GBK編碼的文本文件，轉換為UTF-8編碼的文本文件。
案例分析
案例實現代碼如下：
public class TransDemo {public static void main(String[] args) throws IOException {// 1.定義文件路徑String srcFile = "aa/gbk.txt";String destFile = "aa/utf8.txt";// 2.創建流對象// 2.1 轉換輸入流,指定GBK編碼InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile), "GBK");// 2.2 轉換輸出流,默認utf8編碼OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));// 3.讀寫數據// 3.1 定義數組char[] cbuf = new char[1024];// 3.2 定義長度int len;// 3.3 循環讀取while ((len = isr.read(cbuf)) != -1){// 循環寫出osw.write(cbuf, 0, len);}// 4.釋放資源osw.close();isr.close();} }結果如下：
8.序列化
⑴概述
Java 提供了一種對象序列化的機制。用一個字節序列可以表示一個對象，該字節序列包含該 對象的數據 、 對象的類型 和 對象中存儲的屬性 等信息。字節序列寫出到文件之后，相當于文件中持久保存了一個對象的信息。
反之，該字節序列還可以從文件中讀取回來，重構對象，對它進行反序列化。 對象的數據 、 對象的類型 和 對象中存儲的數據 信息，都可以用來在內存中創建對象。看圖理解序列化：
⑵ObjectOutputStream類
java.io.ObjectOutputStream 類，將Java對象的原始數據類型寫出到文件,實現對象的持久存儲。
構造方法
- public ObjectOutputStream(OutputStream out)： 創建一個指定OutputStream的ObjectOutputStream。
①序列化操作
?一個對象要想序列化，必須滿足兩個條件:
-
該類必須實現 java.io.Serializable 接口， Serializable 是一個標記接口，不實現此接口的類將不會使任何狀態序列化或反序列化，會拋出 NotSerializableException 。
-
該類的所有屬性必須是可序列化的。如果有一個屬性不需要可序列化的，則該屬性必須注明是瞬態的，使用transient 關鍵字修飾。
注意：
靜態優先于非靜態加載到內存中(靜態優先于對象進入到內存中)
被static修飾的成員變量不能被序列化的,序列化的都是對象
示例代碼如下：
public class Employee implements Serializable {public String name;public String address;public transient int age; // transient瞬態修飾成員,不會被序列化public void addressCheck() {System.out.println("Address check : " + name + " ‐‐ " + address);} }②寫出對象方法
- public final void writeObject (Object obj): 將指定的對象寫出。
對象類：
public class Employee implements Serializable {public String name;public String address;public transient int age; // transient瞬態修飾成員,不會被序列化public void addressCheck() {System.out.println("Address check : " + name + " ‐‐ " + address);} }寫出序列化的測試類：
public class SerializeDemo {public static void main(String[] args) throws IOException {Employee e = new Employee();e.name = "zhangsan";e.address = "beijing";e.age = 20;try {// 創建序列化流對象ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("aa/employee.txt"));// 寫出對象out.writeObject(e);// 釋放資源out.close();System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年齡沒有被序列化。} catch (IOException i) {i.printStackTrace();}} }結果如下：
因為是對象格式的存儲導致亂碼了，但還是可以看到值的。從中可以看出，年齡的值沒有寫出到文件中
⑶ObjectInputStream類
ObjectInputStream反序列化流，將之前使用ObjectOutputStream序列化的原始數據恢復為對象
構造方法
- public ObjectInputStream(InputStream in)： 創建一個指定InputStream的ObjectInputStream。
①反序列化操作1
如果能找到一個對象的class文件，我們可以進行反序列化操作，調用 ObjectInputStream 讀取對象的方法：
- public final Object readObject () : 讀取一個對象。
對象類在執行編譯得到時候會生成.class文件
public class Employee implements Serializable {public String name;public String address;public transient int age; // transient瞬態修飾成員,不會被序列化public void addressCheck() {System.out.println("Address check : " + name + " ‐‐ " + address);} }反序列化的代碼如下：
public class DeserializeDemo {public static void main(String[] args) {Employee e = null;try {// 創建反序列化流FileInputStream fileIn = new FileInputStream("aa/employee.txt");ObjectInputStream in = new ObjectInputStream(fileIn);// 讀取一個對象e = (Employee) in.readObject();// 釋放資源in.close();fileIn.close();} catch (IOException i) {// 捕獲其他異常i.printStackTrace();return;} catch (ClassNotFoundException c) {// 捕獲類找不到異常System.out.println("Employee class not found");c.printStackTrace();return;}// 無異常,直接打印輸出System.out.println("Name: " + e.name); // zhangsanSystem.out.println("Address: " + e.address); // beiqingluSystem.out.println("age: " + e.age); // 0} }對于JVM可以反序列化對象，它必須是能夠找到class文件的類。如果找不到該類的class文件，則拋出一個ClassNotFoundException 異常。
②反序列化操作2
另外，當JVM反序列化對象時，能找到class文件，但是class文件在序列化對象之后發生了修改，那么反序列化操作也會失敗，拋出一個 InvalidClassException 異常。發生這個異常的原因如下：
- 該類的序列版本號與從流中讀取的類描述符的版本號不匹配
- 該類包含未知數據類型
- 該類沒有可訪問的無參數構造方法
Serializable接口給需要序列化的類，提供了一個序列版本號。serialVersionUID 該版本號的目的在于驗證序列化的對象和對應類是否版本匹配。
序列號沖突異常的代碼演示：
-
1.原本的對象類如下：
public class Employee implements Serializable {public String name;public String address;public transient int age; // transient瞬態修飾成員,不會被序列化public void addressCheck() {System.out.println("Address check : " + name + " ‐‐ " + address);} } -
2.執行序列化操作的類：
public class SerializeDemo {public static void main(String[] args) throws IOException {Employee e = new Employee();e.name = "zhangsan";e.address = "beijing";e.age = 20;try {// 創建序列化流對象ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("aa/employee.txt"));// 寫出對象out.writeObject(e);// 釋放資源out.close();System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年齡沒有被序列化。} catch (IOException i) {i.printStackTrace();}} } -
3.執行序列化操作之后修改對象類如下：
public class Employee implements Serializable {public String name;public String address;//public transient int age; // transient瞬態修飾成員,不會被序列化//修改年齡的屬性public int age;public void addressCheck() {System.out.println("Address check : " + name + " ‐‐ " + address);} } -
4.修改完對象之后在立馬反序列化：
public class DeserializeDemo {public static void main(String[] args) {Employee e = null;try {// 創建反序列化流FileInputStream fileIn = new FileInputStream("aa/employee.txt");ObjectInputStream in = new ObjectInputStream(fileIn);// 讀取一個對象e = (Employee) in.readObject();// 釋放資源in.close();fileIn.close();} catch (IOException i) {// 捕獲其他異常i.printStackTrace();return;} catch (ClassNotFoundException c) {// 捕獲類找不到異常System.out.println("Employee class not found");c.printStackTrace();return;}// 無異常,直接打印輸出System.out.println("Name: " + e.name); // zhangsanSystem.out.println("Address: " + e.address); // beiqingluSystem.out.println("age: " + e.age); // 0} }執行的結果如下：
public class Employee implements Serializable {//手動給類添加一個序列號private static final long serialVersionUID = 1L;public String name;public String address;public transient int age; // transient瞬態修飾成員,不會被序列化//public int age;public void addressCheck() {System.out.println("Address check : " + name + " ‐‐ " + address);} }
序列號沖突異常的原理和解決方案圖解
解決序列號沖突異常類的設計：
注意：
- 序列化和反序列化的時候如果沒有實現序列化接口,會拋出NotSerializableException沒有序列化異常。類通過實現 java.io.Serializable 接口以啟用其序列化功能。未實現此接口的類將無法使其任何狀態序列化或反序列化。
- Serializable接口也叫標記型接口
要進行序列化和反序列化的類必須實現Serializable接口,此時會給類添加一個標記
當我們進行序列化和反序列化的時候,就會檢測類上是否有這個標記
?有:就可以序列化和反序列化
?沒有:就會拋出 NotSerializableException異常 - 并且要保證序列化和反序列化類的標記要一致。
- 多次序列化對象時記得清緩存，不然可能會報錯
⑷練習：序列化集合
①將存有多個自定義對象的集合序列化操作，保存到 list.txt 文件中。
②反序列化 list.txt ，并遍歷集合，打印對象信息。
案例分析
① 把若干學生對象 ，保存到集合中。
② 把集合序列化。
③ 反序列化讀取時，只需要讀取一次，轉換為集合類型。
④遍歷集合，可以打印所有的學生信息
學生類
public class Student implements Serializable {private static final long serialVersionUID = 1L;private String name;private String nickname;public Student(String name, String nickname) {this.name = name;this.nickname = nickname;}public Student() {}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;} }序列化和反序列化操作
public class SerTest {public static void main(String[] args) throws Exception {// 創建 學生對象Student student = new Student("老王", "laow");Student student2 = new Student("老張", "laoz");Student student3 = new Student("老李", "laol");ArrayList<Student> arrayList = new ArrayList<>();arrayList.add(student);arrayList.add(student2);arrayList.add(student3);// 序列化操作//serializ(arrayList);//反序列化ObjectInputStream ois = new ObjectInputStream(new FileInputStream("aa/list.txt"));// 讀取對象,強轉為ArrayList類型ArrayList<Student> list = (ArrayList<Student>) ois.readObject();for (int i = 0; i < list.size(); i++) {Student s = list.get(i);System.out.println(s.getName() + "‐‐" + s.getNickname());}ois.close();}private static void serializ(ArrayList<Student> arrayList) throws Exception {// 創建 序列化流ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("aa/list.txt"));// 寫出對象oos.writeObject(arrayList);// 釋放資源oos.close();} }結果如下：
9.打印流
⑴概述
平時我們在控制臺打印輸出，是調用 print 方法和 println 方法完成的，這兩個方法都來自于java.io.PrintStream 類，該類能夠方便地打印各種數據類型的值，是一種便捷的輸出方式。
⑵PrintStream類
構造方法
- public PrintStream(String fileName)： 使用指定的文件名創建一個新的打印流。
改變打印流向
System.out就是PrintStream 類型的，只不過它的流向是系統規定的，打印在控制臺上。不過，既然是流對象，我們就可以玩一個"小把戲"，改變它的流向。
代碼案例如下：
public class PrintDemo {public static void main(String[] args) throws FileNotFoundException {// 調用系統的打印流,控制臺直接輸出97System.out.println(97);// 創建打印流,指定文件的名稱PrintStream ps = new PrintStream("aa/ps.txt");// 設置系統的打印流流向,輸出到ps.txtSystem.setOut(ps);// 調用系統的打印流,ps.txt中輸出97System.out.println(97);} }結果如下：
10.I/O異常的處理
⑴JDK1.7前處理方式
之前的入門練習，我們一直把異常拋出，而實際開發中并不能這樣處理，建議使用 try…catch…finally 代碼塊，處理異常部分。
演示代碼如下：
⑵JDK1.7的I/O異常處理方式
還可以使用JDK1.7優化后的 try-with-resource 語句，該語句確保了每個資源在語句結束時關閉。所謂的資源（resource）是指在程序完成后，必須關閉的對象。
格式如下：
try (創建流對象語句，如果多個,使用’;'隔開) {
??// 讀寫數據
} catch (IOException e) {
??e.printStackTrace();
}
代碼如下：
public class IOTest {public static void main(String[] args) {//創建流對象try(FileWriter fw = new FileWriter("aa/aaa.txt");){//寫出字符fw.write(new String("柯基偵探微信公眾號"));} catch (IOException e) {e.printStackTrace();}} }在這個例子中，數據流會在 try 執行完畢后自動被關閉，前提是，這些可關閉的資源必須實現 java.lang.AutoCloseable 接口。
⑶JDK9的改進(擴展知識點了解內容，因為需要同時使用throws拋出異常，操作并不簡潔)
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 IOTest {public static void main(String[] args) throws IOException{//創建字符輸出流對象final FileWriter fw = new FileWriter("aa/bbb.txt");//創建字符輸入流對象FileReader fr = new FileReader("aa/aaa.txt");try(fw;fr) {int b;while((b = fr.read()) != -1){fw.write(b);}} catch (Exception e) {e.printStackTrace();}} }四、util工具包下的補充類
1.屬性集java.util.Properties
⑴ 概述：
java.util.Properties 繼承于 Hashtable ，來表示一個持久的屬性集。它使用鍵值結構存儲數據，每個鍵及其對應值都是一個字符串。該類也被許多Java類使用，比如獲取系統屬性時，System.getProperties 方法就是返回一個 Properties 對象。
⑵Properties類
構造方法
-public Properties() :創建一個空的屬性列表。
基本的存儲方法
-
public Object setProperty(String key, String value) ： 保存一對屬性。
-
public String getProperty(String key) ：使用此屬性列表中指定的鍵搜索屬性值。
-
public Set<String> stringPropertyNames() ：所有鍵的名稱的集合。
public class IOTest {public static void main(String[] args) throws IOException{//創建屬性集對象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));}} }
與流相關的方法
- public void load(InputStream inStream) ： 從字節輸入流中讀取鍵值對。
參數中使用了字節輸入流，通過流對象，可以關聯到某文件上，這樣就能夠加載文本中的數據了。
文本數據格式:
filename=a.txt
length=209385038
location=D:\a.txt
代碼案例如下：
public class IOTest {public static void main(String[] args) throws IOException{//創建屬性集對象Properties pro = new Properties();// 加載文本中信息到屬性集pro.load(new FileInputStream("aa/bbb.txt"));// 遍歷集合并打印Set<String> keys = pro.stringPropertyNames();for (String key : keys) {System.out.println(key+" ‐‐ "+pro.getProperty(key));}} }打印結果如下：
注意：
文本中的數據，必須是鍵值對形式，可以使用空格、等號、冒號等符號分隔。
總結
以上是生活随笔為你收集整理的六、Java中常用的API(通过包进行分类)————File类、IO流的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 支付宝手机网站支付开发详细流程
- 下一篇： 安全生产双重预防体系建设数字化解决方案