當(dāng)前位置：首頁 > 编程语言 > java >内容正文

java

Java - IO流学习笔记

發(fā)布時(shí)間：2024/3/13 java 30 豆豆

生活随笔收集整理的這篇文章主要介紹了 Java - IO流学习笔记小編覺得挺不錯(cuò)的,現(xiàn)在分享給大家,幫大家做個(gè)參考.

1、文件和文件夾

內(nèi)存中存放的數(shù)據(jù)信息在計(jì)算機(jī)關(guān)機(jī)后就會(huì)消失，如果想要長久的保存數(shù)據(jù)，就需要使用到光盤、硬盤等設(shè)備，為了便于數(shù)據(jù)的管理以及檢索，引入了“文件”的概念。一篇文章，一個(gè)圖片，一個(gè)視頻、一個(gè)可執(zhí)行的程序等等，都可以被保存成一個(gè)文件。

從文件的功能上，可以吧文件分成文本文件，視頻文件，音頻文件，可執(zhí)行文件，圖像文件等等類別，但是從數(shù)據(jù)存儲(chǔ)的角度看，所有的文件本質(zhì)上都是一樣的，都是由一個(gè)個(gè)字節(jié)組成，歸根到底都是由0/1組成的，只不過呈現(xiàn)出了不同的狀態(tài)。

大量的文件如果不進(jìn)行分類，那么使用起來會(huì)十分不方便，因此，可以用文件夾對(duì)文件進(jìn)行管理。

2、Java對(duì) File 對(duì)象的一些操作

package IO;import java.io.File; import java.io.IOException;public class TestFile {public static void main(String[] args) throws IOException {// win下是\ ，Linux 下為/File file = new File("e:\\test.txt");// File.separator 可以獲取當(dāng)前操作系統(tǒng)路徑的拼接符號(hào)File file1 = new File("e:" + File.separator + "test.txt");file.canRead(); // 文件是否可讀file.canWrite(); // 文件是否可寫file.getName(); // 獲取文件名稱file.getParent(); // 獲取上級(jí)目錄file.isDirectory(); // 是否是目錄file.isFile();// 是否是文件file.isHidden();// 文件是否隱藏file.length();// 文件的大小file.exists(); // 文件是否存在System.out.println(file == file1); // falseSystem.out.println(file.equals(file1)); // true , 比較的是兩個(gè)對(duì)象的文件路徑System.out.println(file.exists());// if (file.exists()) {// file.delete(); //文件存在就刪除// } else {// file.createNewFile(); // 文件不存在就創(chuàng)建// }file.toString(); // 和相對(duì)路徑一樣System.out.println(file.getPath());// 相對(duì)路徑：相對(duì)位置System.out.println(file.getAbsolutePath());// 絕對(duì)路徑：真實(shí)的準(zhǔn)確的完整的路徑// 文件夾相關(guān)的,上述有關(guān)文件的方法都可以對(duì)文件夾進(jìn)行操作File file2 = new File("e:\\kaoshi\\kexin");//file2.mkdir(); // 幫你在創(chuàng)建文件夾，單層目錄file2.mkdirs(); // 創(chuàng)建多層目錄file2.delete(); // 刪除只能刪除最內(nèi)層的目錄，并且前提是這個(gè)內(nèi)層目錄是空的，如果不為空則不會(huì)刪除String[] list = file2.list(); // 當(dāng)前目錄下，目錄或者文件名稱的數(shù)組File[] files = file2.listFiles(); // 當(dāng)前目錄下，files 對(duì)象的數(shù)組} }

上面File 類的學(xué)習(xí)，可以發(fā)現(xiàn)File對(duì)象只能獲取到一些比較表層的數(shù)據(jù)，比如路徑，文件名，但是并沒有獲取到文件內(nèi)的信息。如何獲得文件的內(nèi)容信息呢，IO流可以幫我們實(shí)現(xiàn)這一需求。

3、I/O 流的概念

簡單來說I/O 流可以當(dāng)做是一根管子，是程序和數(shù)據(jù)源之間溝通的橋梁，所有的數(shù)據(jù)被串行化（串行化就是數(shù)據(jù)按照順序進(jìn)行輸入輸出）的被輸入和輸出。站在程序的角度，往里面讀就是輸入input，往外面寫就是輸出output。

四個(gè)抽象類型的基類

?處理數(shù)據(jù)的單位

處理數(shù)據(jù)的方向

字節(jié)流

字符流

輸入流

InputStream

Reader

輸出流

OutputStream

Writer

4、FileReader 和 FileWriter 操作文本文件。

FileReader的使用

public class TestFileReader {public static void main(String[] args) throws IOException {//程序從文件中讀取內(nèi)容，一個(gè)字符一個(gè)字符的// 有一個(gè)文件-----》創(chuàng)建一個(gè)File對(duì)象File file = new File("e:\\test\\test.txt");// 利用 FileReader 這個(gè)流，將“管子” 懟到源文件上去FileReader fileReader = new FileReader(file);// 利用管子，進(jìn)行讀取的動(dòng)作int n = fileReader.read(); //每次只能讀一個(gè)字符，如果到了文件的末尾，返回的值是-1；while (n != -1) {System.out.print((char) n); // 讀取的是Unicode碼，可以轉(zhuǎn)換為字符輸出n = fileReader.read();}System.out.println();//管子不用了，就把管子關(guān)閉; ----->手動(dòng)關(guān)閉流fileReader.close();//程序從文件中讀取內(nèi)容，多個(gè)字符多字符的// 有一個(gè)文件-----》創(chuàng)建一個(gè)File對(duì)象File file1 = new File("e:\\test\\test.txt");// 利用 FileReader 這個(gè)流，將“管子” 懟到源文件上去FileReader fileReader1 = new FileReader(file);// 利用管子，進(jìn)行讀取的動(dòng)作char[] chars = new char[5]; // 一次性讀取五個(gè)字符int read = fileReader1.read(chars); // 返回值是char數(shù)組的長度while (read >= chars.length) {System.out.print(chars);read = fileReader1.read(chars);}//管子不用了，就把管子關(guān)閉; ----->手動(dòng)關(guān)閉流fileReader.close();} }

FileWriter的使用

public class TestFileWriter {public static void main(String[] args) throws IOException {// 創(chuàng)建一個(gè)文件對(duì)象File file = new File("e:\\test\\test.txt");// 創(chuàng)建FileWriter對(duì)象，將管子懟到文件上去// 沒有文件會(huì)自動(dòng)創(chuàng)建一個(gè)文件，如果有文件則會(huì)覆蓋文件，append如果設(shè)置為true，則不會(huì)覆蓋文件，而是在之前的文件后面進(jìn)行追加。FileWriter fileWriter = new FileWriter(file, true);// 開始往外寫文件String str = "創(chuàng)建FileWriter對(duì)象,開始往外寫文件";// 一個(gè)字符一個(gè)字符的寫for (int i = 0; i < str.length(); i++) {fileWriter.write(str.charAt(i));}// // 直接往外寫// char[] chars = str.toCharArray();// fileWriter.write(chars);// 關(guān)閉流fileWriter.close();} }

使用FileReader 和 FileWriter完成文件的復(fù)制。

public class TestFileReaderWriter {public static void main(String[] args) throws IOException {// 源文件File infile = new File("e:\\test\\test.txt");// 目標(biāo)文件File outFile = new File("e:\\test\\test1.txt");// 輸入的管子FileReader fileReader = new FileReader(infile);// 輸出的管子FileWriter fileWriter = new FileWriter(outFile);// 一遍讀入源文件一遍將讀到的文件寫出去// 方式1// int n = fileReader.read();// while (n != -1) {// fileWriter.write(n);// n = fileReader.read();// }// 方式2char[] chars = new char[5];int length = fileReader.read(chars);while (length != -1) {fileWriter.write(chars);length = fileReader.read(chars);}// 關(guān)閉流后用的先關(guān)閉fileWriter.close();fileReader.close();} }

5、不能用字符流去操作非文本文件，否則得到的文件會(huì)不可用。

文本文件：.txt? .java .c .cpp 等，建議使用字符流去操作

非文件文件：.jpg .mp3等，建議使用字節(jié)流去操作。

6、FileInputStream 和 FileOutputStream 的使用

假設(shè)文件是UTF-8存儲(chǔ)的，那么英文占一個(gè)字節(jié)，中文占三個(gè)字節(jié) --->因此文本文件就不建議用字節(jié)流讀取
如果一個(gè)字節(jié)一個(gè)字節(jié)的讀，那么 read方法底層做了處理，讓返回的數(shù)都是“正數(shù)”，為了避免返回-1的話，不知道是讀入的字節(jié)，還是文件的結(jié)尾。
如果用緩沖數(shù)組byte[]去讀,那么read的時(shí)候，字節(jié)就可以為負(fù)值，-128~127，因?yàn)榕袛辔募┪灿玫氖?“read的返回值是byte數(shù)組的有效長度=-1”，和字節(jié)本身不會(huì)沖突
如果用緩沖數(shù)組取寫，wirte的時(shí)候要注意長度，否則復(fù)制得到的文件會(huì)比源文件大（最后一個(gè)數(shù)組里面有些是無效內(nèi)容）?fileOutputStream.write(byte，0，length); 寫入數(shù)組的第0位到底length位

public class TestFileInputOutputStream {public static void main(String[] args) throws IOException {//程序從文件中讀取內(nèi)容，一個(gè)字符一個(gè)字符的// 有一個(gè)文件-----》創(chuàng)建File對(duì)象File file = new File("e:\\test\\圖片.gif");File file2 = new File("e:\\test\\圖片2.gif");// 利用 FileInputStream FileOutputStream 這個(gè)流，將“管子” 把程序和源文件連接FileInputStream fileInputStream = new FileInputStream(file);FileOutputStream fileOutputStream = new FileOutputStream(file2);// 利用管子，進(jìn)行讀取和寫出的動(dòng)作// 假設(shè)文件是UTF-8存儲(chǔ)的，那么英文占一個(gè)字節(jié)，中文占三個(gè)字節(jié) --->因此文本文件就不建議用字節(jié)流讀取int read = fileInputStream.read(); //每次只能讀一個(gè)字符，如果到了文件的末尾，返回的值是-1；while (read != -1) { // read方法底層做了處理，讓返回的數(shù)都是“正數(shù)”，為了避免返回-1的話，不知道是讀入的字節(jié)，還是文件的結(jié)尾。fileOutputStream.write(read); // 邊讀邊寫read = fileInputStream.read();}System.out.println();//管子不用了，就把管子關(guān)閉; ----->手動(dòng)關(guān)閉流fileOutputStream.close();fileInputStream.close();} }

7、緩沖字節(jié)流（處理流） BufferedInputStream/BufferedOutputStream 的使用

利用緩沖字節(jié)數(shù)組可以減少訪問硬盤的次數(shù)，提升效率，但是訪問次數(shù)還是較多，能不能進(jìn)一步減少訪問硬盤次數(shù)呢？我們可以引入一個(gè)新的流 “緩沖字節(jié)流（處理流）”
其實(shí)BufferedInputStream/BufferedOutputStream底層也是通過新建緩沖數(shù)組進(jìn)行數(shù)據(jù)操作的，size值為8192
如果數(shù)據(jù)流存在著嵌套，那么其實(shí)只要關(guān)閉高級(jí)流，那么里面的字節(jié)流也會(huì)隨之關(guān)閉。

例如BufferedOutputStream 的源碼：（BufferedInputStream類似）

public BufferedOutputStream(OutputStream out) {this(out, 8192);}public BufferedOutputStream(OutputStream out, int size) {super(out);if (size <= 0) {throw new IllegalArgumentException("Buffer size <= 0");}buf = new byte[size];} public class TestBuffer {public static void main(String[] args) throws IOException {//程序從文件中讀取內(nèi)容，一個(gè)字符一個(gè)字符的// 有一個(gè)文件-----》創(chuàng)建File對(duì)象File file = new File("e:\\test\\圖片.gif");File file2 = new File("e:\\test\\圖片2.gif");// 利用 FileInputStream FileOutputStream 這個(gè)流，將“管子” 把程序和源文件連接FileInputStream fileInputStream = new FileInputStream(file);FileOutputStream fileOutputStream = new FileOutputStream(file2);// 功能加強(qiáng)，引入新的流BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);// 開始動(dòng)作其實(shí)BufferedInputStream/BufferedOutputStream底層也是通過新建緩沖區(qū)數(shù)據(jù)操作的，size值為8192byte[] bytes = new byte[1026 * 8];int len = bufferedInputStream.read(bytes);while (len != -1) {bufferedOutputStream.write(bytes, 0, len);// bufferedOutputStream.flush();底層已經(jīng)幫忙做了刷新緩沖區(qū)的操作，不需要手動(dòng)完成刷新len = bufferedInputStream.read(bytes);}// 關(guān)閉流，倒著關(guān)閉// 如果數(shù)據(jù)流存在著嵌套，那么其實(shí)只要關(guān)閉高級(jí)流，那么里面的字節(jié)流也會(huì)隨之關(guān)閉。bufferedOutputStream.close();bufferedInputStream.close();// fileOutputStream.close(); 可以不寫// fileInputStream.close(); 可以不寫} }

8、緩沖字符流（處理流） BufferedReader/BufferedWriter 的使用

public class TestBuffer02 {public static void main(String[] args) throws IOException {//程序從文件中讀取內(nèi)容，一個(gè)字符一個(gè)字符的// 有一個(gè)文件-----》創(chuàng)建File對(duì)象File file = new File("e:\\test\\test.txt");File file2 = new File("e:\\test\\test1.txt");// 利用 FileInputStream FileOutputStream 這個(gè)流，將“管子” 把程序和源文件連接FileReader fileReader = new FileReader(file);FileWriter fileWriter = new FileWriter(file2);// 功能加強(qiáng)，引入新的流BufferedReader bufferedReader = new BufferedReader(fileReader);BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);// 開始動(dòng)作其實(shí)BufferedInputStream/BufferedOutputStream底層也是通過新建緩沖區(qū)數(shù)據(jù)操作的，size值為8192// char[] chars = new char[1024];// int len = bufferedReader.read(chars);// while (len != -1) {// bufferedWriter.write(chars, 0, len);// len = bufferedReader.read(chars);// }// 新的方式String str = bufferedReader.readLine(); // 每次讀取文本文件中的一行while (str != null) {bufferedWriter.write(str);bufferedWriter.newLine(); // 注意寫入時(shí)，每行之間要新加一行，否則復(fù)制的文件中沒有換行。str = bufferedReader.readLine();}// 關(guān)閉流，倒著關(guān)閉// 如果數(shù)據(jù)流存在著嵌套，那么其實(shí)只要關(guān)閉高級(jí)流，那么里面的字節(jié)流也會(huì)隨之關(guān)閉。bufferedWriter.close();bufferedReader.close();// FileWriter.close(); 可以不寫// FileReader.close(); 可以不寫} }

9、轉(zhuǎn)換流（將字節(jié)流和字符流進(jìn)行轉(zhuǎn)換）InputStreamReader / OutputStreamWriter的使用。

看后綴，這兩個(gè)轉(zhuǎn)換流屬于字符流。

InputStreamReader：字節(jié)輸入流轉(zhuǎn)換為字符輸入流，完成文件到程序
OutputStreamWriter：字符輸出流轉(zhuǎn)換為字節(jié)輸出流，完成程序到文件

public class Test_InputStreamReader_OutputStreamWriter {public static void main(String[] args) throws IOException {// 源文件和目標(biāo)文件File file = new File("e:\\test\\test.txt");File file1 = new File("e:\\test\\test1.txt");// 輸入方向，創(chuàng)建一個(gè)字節(jié)流接觸文件，創(chuàng)建轉(zhuǎn)換流，負(fù)責(zé)將字節(jié)流轉(zhuǎn)換為字符流（相當(dāng)于一個(gè)處理流）// 創(chuàng)建轉(zhuǎn)換流，負(fù)責(zé)將字節(jié)流轉(zhuǎn)換為字符流（相當(dāng)于一個(gè)處理流）// 編碼格式要保持統(tǒng)一，否則會(huì)出現(xiàn)亂碼; 如果不手動(dòng)寫編碼格式，會(huì)自動(dòng)獲取編譯器的編碼格式FileInputStream fileInputStream = new FileInputStream(file);InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "utf-8");// 輸出方向FileOutputStream fileOutputStream = new FileOutputStream(file1);OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");// 開始動(dòng)作char[] chars = new char[20];int len = inputStreamReader.read(chars);while (len != -1) {outputStreamWriter.write(chars);len = inputStreamReader.read(chars);}// 關(guān)閉流outputStreamWriter.close();inputStreamReader.close();} }

10、System類對(duì)IO屬性的支持

System.in：從鍵盤輸入
System.out：輸出到控制臺(tái)

11、數(shù)據(jù)流DataInputStream / DataOutputStream

將文件中存儲(chǔ)的基本數(shù)據(jù)類型和字符串寫入到內(nèi)存的變量中，但是讀的過程中，要注意變量的類型要和寫入變量的類型要一一對(duì)應(yīng)，否則會(huì)讀出錯(cuò)。

12、對(duì)象流 ObjectInputStream 和 ObjectOutputStream

用于存儲(chǔ)和讀取基本數(shù)據(jù)類型或者對(duì)象的處理流，他的強(qiáng)大之處就是可以把Java中的對(duì)象寫入到數(shù)據(jù)源中，也能把對(duì)象從數(shù)據(jù)源中還原回來。

ObjectOutputStream : 將一個(gè)對(duì)象轉(zhuǎn)化為字節(jié)寫到一個(gè)文件中去，以此來實(shí)現(xiàn)對(duì)象的持久化保存，這個(gè)過程被稱為序列化。

ObjectInputStream :?從文件中讀取被序列化的對(duì)象, 稱作反序列化。

序列化的可以參考以下鏈接

Java 反射reflect 序列化_材料小菜鳥的博客-CSDN博客

13、什么是同步，什么是異步？

同步：如果有多個(gè)任務(wù)或者事件要發(fā)生，這些任務(wù)或者事件必須逐個(gè)進(jìn)行，一個(gè)事件任務(wù)的執(zhí)行會(huì)導(dǎo)致整個(gè)流程的暫時(shí)等待，其他事件沒有辦法并發(fā)的執(zhí)行下去；

異步：如果有多個(gè)任務(wù)或者事件要發(fā)生，那么這些事件可以并發(fā)的執(zhí)行

例子：一個(gè)任務(wù)包括兩個(gè)子任務(wù)A和B，同步時(shí)，A執(zhí)行過程中B只能等待，直到A執(zhí)行完畢后,B才能繼續(xù)執(zhí)行；異步時(shí)，AB可以并發(fā)的執(zhí)行，B不用等待A執(zhí)行結(jié)束。

14、什么是阻塞，什么是非阻塞？

阻塞：某個(gè)事件或者任務(wù)執(zhí)行過程中，發(fā)出一個(gè)請(qǐng)求，但是由于該請(qǐng)求操作需要的條件不滿足而無法繼續(xù)執(zhí)行時(shí)，他就一直在那等待，直到條件滿足后繼續(xù)執(zhí)行；

非阻塞：某個(gè)事件或者任務(wù)執(zhí)行過程中，發(fā)出一個(gè)請(qǐng)求，如果該請(qǐng)求操作需要的條件不滿足，會(huì)立即返回一個(gè)標(biāo)志信息告知條件不滿足，不會(huì)一直等待。

舉個(gè)簡單的例子：

假如我要讀取一個(gè)文件中的內(nèi)容，如果此時(shí)文件中沒有內(nèi)容可讀，對(duì)于同步來說就是會(huì)一直在那等待，直至文件中有內(nèi)容可讀；而對(duì)于非阻塞來說，就會(huì)直接返回一個(gè)標(biāo)志信息告知文件中暫時(shí)無內(nèi)容可讀。

阻塞和非阻塞著重點(diǎn)在于發(fā)出一個(gè)請(qǐng)求操作時(shí)，如果進(jìn)行操作的條件不滿足是否會(huì)返會(huì)一個(gè)標(biāo)志信息告知條件不滿足。理解阻塞和非阻塞可以同線程阻塞類比地理解，當(dāng)一個(gè)線程進(jìn)行一個(gè)請(qǐng)求操作時(shí)，如果條件不滿足，則會(huì)被阻塞，即在那等待條件滿足。

有關(guān)BIO/NIO/AIO的知識(shí)，后續(xù)學(xué)習(xí)完網(wǎng)絡(luò)相關(guān)的在來補(bǔ)充。

15、BIO（Bolcking IO）

同步阻塞IO，jdk1.4之前只有這一種IO模型，指的是調(diào)用發(fā)起后，會(huì)阻塞線程，直到獲得結(jié)果，服務(wù)端一個(gè)線程只能同時(shí)處理一個(gè)客戶端的請(qǐng)求。

問題：服務(wù)端在等待接收客戶端請(qǐng)求時(shí)阻塞，等待客戶端的連接，有多個(gè)客戶端連接時(shí)，由于client1先和服務(wù)端進(jìn)行了連接，此時(shí)服務(wù)端只能處理client1 的請(qǐng)求，什么時(shí)候client1處理完，什么時(shí)候才可以處理其他的請(qǐng)求，此時(shí)client2發(fā)送請(qǐng)求，服務(wù)端是沒辦法處理的

TCP/IP底層使用的是BIO，同步阻塞IO，發(fā)起請(qǐng)求后，必須等待接收到響應(yīng)后，代碼才能繼續(xù)向下執(zhí)行，服務(wù)端一個(gè)線程只能處理一個(gè)客戶端的請(qǐng)求

解決方案：服務(wù)端為每個(gè)客戶端創(chuàng)建一個(gè)線程，但是如果客戶端特別多，服務(wù)器就需要?jiǎng)?chuàng)建對(duì)應(yīng)數(shù)量的子線程，由于每個(gè)子線程都有自己的獨(dú)立線程區(qū)，子線程創(chuàng)建多了就會(huì)產(chǎn)生內(nèi)存不足等問題，而且子線程也需要調(diào)度，切換和銷毀也都是非常消耗性能的。使用線程池可以一定程度上提升線程創(chuàng)建和銷毀的性能，但是調(diào)度和切換帶來的性能下降還是無法解決。

16、NIO?

new IO 或者 Non-Blocking IO，NIO的特性就是同步非阻塞IO；

調(diào)用發(fā)起后，等待獲得結(jié)果，但是不會(huì)阻塞線程，NIO中服務(wù)端的一個(gè)線程可以處理多個(gè)客戶端。

NIO解決了使用BIO服務(wù)端創(chuàng)建過多的子線程產(chǎn)生內(nèi)存消耗、子線程調(diào)度切換銷毀等帶來的性能消耗問題。

NIO支持面向緩沖的，基于通道的I/O操作方法。 NIO提供了與傳統(tǒng)BIO模型中的?Socket?和?ServerSocket?相對(duì)應(yīng)的?SocketChannel?和?ServerSocketChannel?兩種不同的套接字通道實(shí)現(xiàn),兩種通道都支持阻塞和非阻塞兩種模式。阻塞模式使用就像傳統(tǒng)中的支持一樣，比較簡單，但是性能和可靠性都不好；非阻塞模式正好與之相反。對(duì)于低負(fù)載、低并發(fā)的應(yīng)用程序，可以使用同步阻塞I/O來提升開發(fā)速率和更好的維護(hù)性；對(duì)于高負(fù)載、高并發(fā)的（網(wǎng)絡(luò)）應(yīng)用，應(yīng)使用 NIO 的非阻塞模式來開發(fā)。

17、Buffer緩沖區(qū)

Buffer緩沖區(qū)，緩沖區(qū)中緩存的是流數(shù)據(jù)，BIO直接操作流數(shù)據(jù)，NIO模型變?yōu)椴僮骶彺鎱^(qū)數(shù)據(jù)通過channel管道進(jìn)行傳輸。

Buffer緩沖區(qū)是一個(gè)對(duì)象，他包含一些要寫入或者剛讀出的數(shù)據(jù)，緩沖區(qū)實(shí)質(zhì)上是一個(gè)數(shù)組，NIO所有的數(shù)據(jù)都是用緩沖區(qū)處理，寫入數(shù)據(jù)時(shí)，首先寫到緩沖區(qū)中，讀數(shù)據(jù)也是從緩沖區(qū)中去讀。

Buffer的主要實(shí)現(xiàn)類

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer

在NIO中，Buffer類是抽象類，是所有緩存的父類，提供了除boolean外基本數(shù)據(jù)類型的緩存類，但是我們一般只使用ByteBuffer，因?yàn)門CP協(xié)議是基于字節(jié)的，所以緩存區(qū)也使用的是Byte類型的緩存區(qū)

18、channel 通道

通道是對(duì)原IO包中流的一個(gè)模擬，源與目標(biāo)的連接是借助一個(gè)Channel對(duì)象（通道）實(shí)現(xiàn)的，channel 不能直接訪問數(shù)據(jù)，需要和緩沖區(qū)進(jìn)行交互。

舉個(gè)栗子：

A和B兩個(gè)地區(qū)之間可以進(jìn)行鐵路運(yùn)輸，他們分別在火車站旁邊有個(gè)倉庫AB；這里的鐵路就是管道channel，而AB兩個(gè)倉庫就是緩沖區(qū)Buffer，倉庫用于臨時(shí)存儲(chǔ)運(yùn)來的貨物，即緩沖區(qū)用于臨時(shí)存儲(chǔ)傳輸來的數(shù)據(jù)。

Channel的主要實(shí)現(xiàn)類

1 、FileChannel:用于讀取、寫入、映射和操作文件的通道。

2、 DatagramChannel:通過UDP讀寫網(wǎng)絡(luò)中的數(shù)據(jù)通道。

3 、SocketChannel:通過tcp讀寫網(wǎng)絡(luò)中的數(shù)據(jù)。

4 、ServerSocketChannel:可以監(jiān)聽新進(jìn)來的tcp連接，對(duì)每一個(gè)連接都創(chuàng)建一個(gè)SocketChannel。
其中FileChannel沒有繼承SelectableChannel，因此不支持非阻塞操作；其他的類都支持非阻塞操作。

獲取通道的方式

1、通過getChannel()方法獲取

前提是該類支持該方法。支持該類的方法有：

FileInputStream/FileOutputStream，RandomAccessFile，Socket，ServerSocket ，DatagramSocket

2、通過靜態(tài)方法open（）

3、通過jdk1.7中Files的newByteChannel()方法

NIO的底層工作原理

首先Buffer的工作機(jī)制

1、buffer數(shù)組的幾個(gè)屬性設(shè)置

public abstract class Buffer {private int mark = -1; // 用于記錄當(dāng)前 position 的前一個(gè)位置或者默認(rèn)是 -1private int position = 0; // 下一個(gè)要操作的數(shù)據(jù)元素的位置private int limit; // 緩沖區(qū)數(shù)組中不可操作的下一個(gè)元素的位置 limit <=capacityprivate int capacity; // 緩沖區(qū)數(shù)組的長度 }

2、初始化時(shí)，默認(rèn)狀態(tài)為：

3、開始往數(shù)組中寫入字節(jié)的時(shí)候，變?yōu)橄聢D，position會(huì)移動(dòng)到數(shù)據(jù)結(jié)束的下一個(gè)位置

?4、調(diào)用buffer.flip() 方法，byte數(shù)組中的內(nèi)容不變，position賦值給limit，position重置為0；適合讀之前的操作

public final Buffer flip() {limit = position;position = 0;mark = -1;return this;}

?5、調(diào)用buffer.clear() 方法，byte數(shù)組中的內(nèi)容不變，position重置為0，capacity賦值給limit，適合寫之前的操作

public final Buffer clear() {position = 0;limit = capacity;mark = -1;return this;}

6、mark()方法回將position的值賦給mark，reset() 方法是講mark的值附回給position，這里是jdk1.8中的源碼和網(wǎng)上的博客大多不一樣。

public final Buffer mark() {mark = position;return this;}public final Buffer reset() {int m = mark;if (m < 0)throw new InvalidMarkException();position = m;return this;}

代碼樣例：

public class TestByteBuffer {public static void main(String[] args) {// 方式一：創(chuàng)建byteBuffer對(duì)象，ByteBuffer是抽象類，使用allocate(capacity)方法給buffer分配緩存空間// 底層使用byte[]數(shù)組存儲(chǔ)緩存數(shù)據(jù)，數(shù)組的長度為傳入的參數(shù)capacityByteBuffer byteBuffer = ByteBuffer.allocate(1024);// 方式二：根據(jù)傳遞的內(nèi)容自動(dòng)創(chuàng)建緩存區(qū)大小，大小為內(nèi)容的長度// ByteBuffer byteBuffer1 = ByteBuffer.wrap("hello,world".getBytes());// 向緩存區(qū)中放內(nèi)容byteBuffer.put("hello".getBytes());// position 代表下一個(gè)存放位置的開始，初始為0System.out.println(byteBuffer.position()); // 5// 最大限制，就是capacitySystem.out.println(byteBuffer.limit()); //1024// 獲取到緩存區(qū)中存值的數(shù)組 byteBuffer.array();byte[] array = byteBuffer.array();System.out.println(new String(array)); //hello000000000000... 0代表空格// 這種方法要保證不能對(duì)position進(jìn)行重置操作System.out.println(new String(array, 0, byteBuffer.position())); // hello// 重置buffer// byte數(shù)組中的內(nèi)容不變，position重置為0，capacity賦值給limit，適合寫之前的操作byteBuffer.clear();// byte數(shù)組中的內(nèi)容不變，position賦值給limit，position重置為0 適合讀之前的操作byteBuffer.flip();} }

Selector簡介

selector一般被稱為選擇器，也稱為多路復(fù)用器。是Java NIO核心組件中的一個(gè)，用于檢查一個(gè)躲著多個(gè)NIO channel 通道的狀態(tài)是否處于可讀或者可寫。如此可以實(shí)現(xiàn)單線程管理多個(gè)channels，也就是單個(gè)線程管理多個(gè)網(wǎng)絡(luò)連接。

可選擇通道SelectableChannel?

判斷一個(gè)channel是否可以被selector復(fù)用，是判斷是否繼承了抽象類SelectableChannel，如果繼承了就可以被復(fù)用，否則就不能。?
SelectableChannel 類提供了實(shí)現(xiàn)通道的可選擇性所需要的公共方法，FileChannel類沒有繼承SelectableChannel類，因此不是可選通道。
一個(gè)通道可以被注冊(cè)到多個(gè)選擇器上，但是對(duì)每個(gè)選擇器而言，只能注冊(cè)一次。通道和選擇器之間的關(guān)系，是使用注冊(cè)的方式完成。SelectableChannel可以被注冊(cè)到Selector對(duì)象上，注冊(cè)的時(shí)候，需要制定通道的那些操作是Selector感興趣的，如可讀，可寫等。

Channel注冊(cè)到Selector

使用Channel.register(Selector sel, int ops)方法，將一個(gè)通道注冊(cè)到一個(gè)選擇器。第一個(gè)參數(shù)：指定通道要注冊(cè)的選擇器，第二個(gè)參數(shù)指定選擇器需要查詢的通道操作。

可以供選擇器查詢的通道操作，類型上分為以下四種。

SelectionKey.OP_READ? 可讀

SelectionKey.OP_WRITE 可寫

SelectionKey.OP_CONNECT 連接

SelectionKey.OP_ACCEPT 接收

通過“位或”操作實(shí)現(xiàn)對(duì)多通道感興趣? int key=SelectionKey.OP_READ |?SelectionKey.OP_WRITE

選擇器查詢的不是通道的操作，而是通道某個(gè)操作的一種就緒狀態(tài)。就是說，一旦通道具備完成某個(gè)操作的條件，就標(biāo)識(shí)該通道的這個(gè)操作依據(jù)就緒，就可以被selector查詢到，程序就可以對(duì)通道進(jìn)行對(duì)應(yīng)的操作。如：某個(gè)SocketChannel可以連接到一個(gè)服務(wù)器，則處于連接就緒

選擇鍵?SelectionKey

channel注冊(cè)到selector后，并且一旦處于某種就緒狀態(tài)，就可以被選擇器查詢到，這個(gè)功能使用Selector的select()方法完成。

selector可以不斷查詢channel中發(fā)生的操作的就緒狀態(tài)，并且挑選感興趣的操作就緒狀態(tài)，一旦通道有操作的就緒狀態(tài)達(dá)成，并且是selector感興趣的操作，就會(huì)被selector選擇，放入選擇鍵集合中。

一個(gè)選擇鍵，首先包含了注冊(cè)在selector的通道操作類型，比如可讀狀態(tài)，也包含了特定的通道與特定選擇器之間的注冊(cè)關(guān)系。

選擇鍵的概念，和事件的概念比較相似，差別是事件是觸發(fā)模式，選擇鍵是主動(dòng)查詢模式。

Selector的使用

創(chuàng)建選擇器 Selector selector = Selector.open();

注冊(cè)channel 到選擇器

獲取通道?ServerSocketChannel ssc = ServerSocketChannel.open();

設(shè)置為非阻塞模式??ssc.configureBlocking(false);

綁定連接??ssc.bind(new InetSocketAddress("127.0.0.1", 9999));

將通道注冊(cè)到選擇器上，并制定監(jiān)聽事件?ssc.register(selector, SelectionKey.OP_ACCEPT);

輪詢查詢就緒操作

?selector.select(); 可以查詢已經(jīng)就緒的通道操作，這些就緒的狀態(tài)集合，存在一個(gè)元素是SelectionKey的Set集合中。 循環(huán)調(diào)用這個(gè)方法，監(jiān)測(cè)通道的就緒狀態(tài)

幾個(gè)重載的select()方法：

select()：阻塞方法，有至少一個(gè)通道在注冊(cè)的事件上就緒了；返回值為int類型，表示有多少個(gè)通道就緒了。（更準(zhǔn)確的說是，前一次select()方法到這一次select()方法之間的時(shí)間段內(nèi)，有多少通道變成就緒狀態(tài)。）一旦調(diào)用select()方法返回值不為0時(shí)，在Selector中有一個(gè)selectedKeys()方法，用來訪問選擇鍵集合

select(long timeout)：長阻塞時(shí)間為timeouthaomia

selectNow()：非阻塞，只要有通道就緒就立刻返回。

遍歷selectedKeys()方法返回的set集合，獲取就緒的channel集合

遍歷channel集合，判斷就緒事件類型，實(shí)現(xiàn)具體業(yè)務(wù)操作

根據(jù)業(yè)務(wù)，是否需要再次注冊(cè)監(jiān)聽事件，重復(fù)執(zhí)行上述操作。

停止選擇的方法

選擇器執(zhí)行選擇的過程，系統(tǒng)底層會(huì)一次詢問每個(gè) 通道是否就緒，這個(gè)過程可能會(huì)造成調(diào)用線程進(jìn)入阻塞狀態(tài)，有以下幾種方式可以喚醒在select()方法中阻塞的線程。

wakeup()：調(diào)用Selector對(duì)象的wakeup()方法讓在阻塞狀態(tài)下的select()方法立刻返回

close()方法：通過該方法關(guān)閉Selector，這個(gè)方法使任何一個(gè)在選擇操作中阻塞的線程都被喚醒，同時(shí)使得注冊(cè)到這個(gè)Selector上的所有channel被注銷，所有的鍵被取消，但是channel本身不會(huì)被關(guān)閉。

注意：與selector 一起使用時(shí)，channel必須處于非阻塞模式，否則將拋出異常IllegalBlockingModeExcption；因此FileChannel不能和selector一起使用，因?yàn)镕ileChannel不能切換到非阻塞模式，而套接字相關(guān)的通道都可以

一個(gè)通道并不是要支持所有四種操作，如服務(wù)器通道ServerSocketChannel支持ACCEPT操作，而SocketChannel不支持。可以通過通道上的validOps()方法，獲取特定通道下支持的操作集合。

NIO實(shí)現(xiàn)服務(wù)端和客戶端的連接

服務(wù)端

/** Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved.*/package IO;import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectableChannel; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set;public class TestSeverSocketChannel {public static void main(String[] args) throws IOException, InterruptedException {// 創(chuàng)建TCP服務(wù)端的管道ServerSocketChannel ssc = ServerSocketChannel.open();// 默認(rèn)管道是阻塞的，因此要手動(dòng)設(shè)置為非阻塞模式ssc.configureBlocking(false);// 綁定對(duì)應(yīng)的ip 端口號(hào)ssc.bind(new InetSocketAddress("127.0.0.1", 9999));// 創(chuàng)建選擇器（多路復(fù)用器）Selector selector = Selector.open();//將管道注冊(cè)到多路復(fù)用器上 --->參數(shù)1,多路復(fù)用器，參數(shù)2.多路復(fù)用器的監(jiān)聽服務(wù)端接收客戶端的狀態(tài)（此時(shí)沒有狀態(tài)）// 如果接收到了客戶端，此時(shí)管道會(huì)變?yōu)樵摖顟B(tài)ssc.register(selector, SelectionKey.OP_ACCEPT);while (true) {// 選擇管道的狀態(tài) 沒有狀態(tài)會(huì)阻塞，有狀態(tài)會(huì)繼續(xù)執(zhí)行selector.select();System.out.println("------------------");// 獲取所有被監(jiān)聽到的狀態(tài)Set<SelectionKey> selectionKeys = selector.selectedKeys();// 獲取迭代器，方便后續(xù)操作，當(dāng)然也可以用foreach遍歷Iterator<SelectionKey> iterator = selectionKeys.iterator();while (iterator.hasNext()) {SelectionKey next = iterator.next();// 服務(wù)端接收到了客戶端，Accept狀態(tài)被監(jiān)聽到if (next.isAcceptable()) {System.out.println(next.isAcceptable());SocketChannel accept = ssc.accept();// 這個(gè)管道是客戶端管道,可以理解是在服務(wù)端的這頭accept.configureBlocking(false);// 設(shè)置客戶端的管道在服務(wù)端這頭為非阻塞//System.out.println(accept);// 將客戶端管道注冊(cè)到多路復(fù)用器，監(jiān)聽管道中內(nèi)容的狀態(tài)accept.register(selector, SelectionKey.OP_READ);} else if (next.isReadable()) { // 管道中有數(shù)據(jù)// 可讀狀態(tài)時(shí)，獲取被選中的管道SelectableChannel sc = next.channel();// 通過客戶端管道接收數(shù)據(jù),放入緩存中ByteBuffer allocate = ByteBuffer.allocate(1024);((SocketChannel) sc).read(allocate);byte[] array = allocate.array();String s = new String(array, 0, allocate.position());System.out.println(s);sc.register(selector, SelectionKey.OP_WRITE);// 讀完之后監(jiān)聽寫的狀態(tài)} else if (next.isWritable()) {Thread.sleep(1000);SelectableChannel sc = next.channel();// 服務(wù)端向客戶端發(fā)送數(shù)據(jù)((SocketChannel) sc).write(ByteBuffer.wrap("你好".getBytes()));sc.register(selector, SelectionKey.OP_READ); // 寫完之后監(jiān)聽讀}// 去除已經(jīng)被監(jiān)聽到的狀態(tài)iterator.remove();}}} }

客戶端

/** Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved.*/package IO;import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set;public class TestSocketChannel {public static void main(String[] args) throws IOException, InterruptedException {// 創(chuàng)建客戶端管道SocketChannel sc = SocketChannel.open();// 設(shè)置為非阻塞sc.configureBlocking(false);// 創(chuàng)建多路復(fù)用器Selector selector = Selector.open();// 將客戶端管道注冊(cè)到多路復(fù)用器中sc.register(selector, SelectionKey.OP_CONNECT);// 連接服務(wù)端sc.connect(new InetSocketAddress("127.0.0.1", 9999));while (true) {// 選擇客戶端管道的狀態(tài)selector.select();// 獲取所有被監(jiān)聽到的狀態(tài)Set<SelectionKey> selectionKeys = selector.selectedKeys();// 通過迭代器獲取所有被監(jiān)聽到的狀態(tài)，方便后續(xù)操作Iterator<SelectionKey> iterator = selectionKeys.iterator();while (iterator.hasNext()) {SelectionKey next = iterator.next();//判斷客戶端是否連接了服務(wù)端,if (next.isConnectable()) {// 此時(shí)是掛起狀態(tài)，并沒有真正連接System.out.println(sc); // java.nio.channels.SocketChannel[connection-pending remote=/127.0.0.1:9999]// 讓客戶端管道掛起的狀態(tài)變成真正的鏈接狀態(tài)if (sc.isConnectionPending()) {sc.finishConnect();System.out.println(sc);// java.nio.channels.SocketChannel[connected local=/127.0.0.1:54278 remote=/127.0.0.1:9999]}// 向服務(wù)端輸出一句話ByteBuffer wrap = ByteBuffer.wrap("success".getBytes());sc.write(wrap);// 監(jiān)聽客戶端管道中有數(shù)據(jù)的狀態(tài)sc.register(selector, SelectionKey.OP_READ);} else if (next.isReadable()) {// 通過客戶端管道接收數(shù)據(jù),放入緩存中ByteBuffer allocate = ByteBuffer.allocate(1024);((SocketChannel) sc).read(allocate);byte[] array = allocate.array();String s = new String(array, 0, allocate.position());System.out.println(s);sc.register(selector, SelectionKey.OP_WRITE); // 讀完監(jiān)聽寫// 想服務(wù)端寫數(shù)據(jù)} else if (next.isWritable()) {Thread.sleep(1000);sc.write(ByteBuffer.wrap("nihao".getBytes()));sc.register(selector, SelectionKey.OP_READ);// 寫完監(jiān)聽讀}}}} }

Pipe管道

Java NIO管道是兩個(gè)線程之間的單向數(shù)據(jù)連接，Pipe中有一個(gè)source通道和一個(gè)sink通道，數(shù)據(jù)會(huì)被寫到sink通道中，然后從source通道中讀取。

創(chuàng)建管道 Pipe pipe = Pipe.open();

FileLock 文件鎖

多個(gè)程序同時(shí)訪問、修改一個(gè)文件，很容易出現(xiàn)文件數(shù)據(jù)不同步的問題。給文件加一個(gè)鎖，同一時(shí)間，只能有同一個(gè)程序修改某個(gè)文件，或者程序都只能只讀此文件，就解決了同步問題。

文件鎖是進(jìn)程級(jí)別的，不是線程級(jí)別的。無法解決多線程并發(fā)訪問、修改一個(gè)文件的問題。

文件鎖是當(dāng)前程序所屬的JVM實(shí)例持有的，一旦獲取到文件鎖（對(duì)文件加鎖），要調(diào)用release()方法，或者關(guān)閉對(duì)應(yīng)的FileChannel對(duì)象，或者當(dāng)JVM退出，才會(huì)釋放這個(gè)鎖。

一旦某個(gè)進(jìn)程對(duì)某個(gè)文件加鎖，在釋放這個(gè)鎖之前，此進(jìn)程不能在對(duì)此文件加鎖，就是說JVM實(shí)例在同一個(gè)文件上的文件鎖是不重疊的。

文件鎖分類

排他鎖：又叫獨(dú)占鎖，對(duì)文件加排他鎖后，該進(jìn)程可以對(duì)此文件進(jìn)行讀寫操作，其他進(jìn)程不能讀寫此文件，直到該進(jìn)程釋放文件鎖。
共享鎖：某個(gè)進(jìn)程對(duì)文件加共享鎖，其他進(jìn)程也可以訪問該文件，但是都是只讀操作。

獲取文件鎖的方法

lock() 對(duì)整個(gè)文件加鎖，默認(rèn)排他鎖
lock(long position, long size , boolean shared)? 自定義加鎖方式，前兩個(gè)參數(shù)指定加鎖的部分（可以只對(duì)此文件部分內(nèi)容加鎖），第三個(gè)參數(shù)指定是否為共享鎖
tryLock() 對(duì)整個(gè)文件加鎖，默認(rèn)為排他鎖
tryLock(long position, long size , boolean shared)? 自定義加鎖方式

lock和?tryLock 的區(qū)別：

lock是阻塞式的，如果未獲取到文件鎖，會(huì)一直阻塞當(dāng)前線程，直到獲取文件鎖
tryLock是非阻塞式的，嘗試獲取文件鎖，獲取成功就返回鎖對(duì)象，失敗返回null，不會(huì)阻塞當(dāng)前線程。

AIO?

Asynchronous IO:異步非阻塞IO，在執(zhí)行時(shí)，當(dāng)前線程不會(huì)阻塞，調(diào)用發(fā)起后，不需要等待返回結(jié)果（結(jié)果是以事件驅(qū)動(dòng)的形式返回），而且也不需要多線程就可以實(shí)現(xiàn)多客戶端訪問。

AIO實(shí)現(xiàn)服務(wù)端和客戶端的連接

服務(wù)端

客戶端

總結(jié)

以上是生活随笔為你收集整理的Java - IO流学习笔记的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。

上一篇： win11提示找不到gpedit.msc
下一篇： [JZOJ3385] [NOIP2013