Java - IO流学习笔记
生活随笔
收集整理的這篇文章主要介紹了
Java - IO流学习笔记
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
1、文件和文件夾
內存中存放的數據信息在計算機關機后就會消失，如果想要長久的保存數據，就需要使用到光盤、硬盤等設備，為了便于數據的管理以及檢索，引入了“文件”的概念。一篇文章，一個圖片，一個視頻、一個可執行的程序等等，都可以被保存成一個文件。
從文件的功能上，可以吧文件分成 文本文件，視頻文件，音頻文件，可執行文件，圖像文件等等類別，但是從數據存儲的角度看，所有的文件本質上都是一樣的，都是由一個個字節組成，歸根到底都是由0/1組成的，只不過呈現出了不同的狀態。
大量的文件如果不進行分類，那么使用起來會十分不方便，因此，可以用文件夾對文件進行管理。
2、Java對 File 對象的一些操作
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 可以獲取當前操作系統路徑的拼接符號File file1 = new File("e:" + File.separator + "test.txt");file.canRead(); // 文件是否可讀file.canWrite(); // 文件是否可寫file.getName(); // 獲取文件名稱file.getParent(); // 獲取上級目錄file.isDirectory(); // 是否是目錄file.isFile();// 是否是文件file.isHidden();// 文件是否隱藏file.length();// 文件的大小file.exists(); // 文件是否存在System.out.println(file == file1); // falseSystem.out.println(file.equals(file1)); // true , 比較的是兩個對象的文件路徑System.out.println(file.exists());// if (file.exists()) {// file.delete(); //文件存在就刪除// } else {// file.createNewFile(); // 文件不存在就創建// }file.toString(); // 和相對路徑一樣System.out.println(file.getPath());// 相對路徑：相對位置System.out.println(file.getAbsolutePath());// 絕對路徑：真實的準確的完整的路徑// 文件夾相關的,上述有關文件的方法都可以對文件夾進行操作File file2 = new File("e:\\kaoshi\\kexin");//file2.mkdir(); // 幫你在創建文件夾，單層目錄file2.mkdirs(); // 創建多層目錄file2.delete(); // 刪除只能刪除最內層的目錄，并且前提是這個內層目錄是空的，如果不為空則不會刪除String[] list = file2.list(); // 當前目錄下，目錄或者文件名稱的數組File[] files = file2.listFiles(); // 當前目錄下，files 對象的數組} }上面File 類的學習，可以發現File對象只能獲取到一些比較表層的數據，比如路徑，文件名，但是并沒有獲取到文件內的信息。如何獲得文件的內容信息呢，IO流可以幫我們實現這一需求。
3、I/O 流的概念
簡單來說I/O 流 可以當做是一根管子，是程序和數據源之間溝通的橋梁，所有的數據被串行化（串行化就是數據按照順序進行輸入輸出）的被輸入和輸出。站在程序的角度，往里面讀就是輸入input，往外面寫就是輸出output。
四個抽象類型的基類
| ?處理數據的單位 處理數據的方向 | 字節流 | 字符流 |
| 輸入流 | InputStream | Reader |
| 輸出流 | OutputStream | Writer |
4、FileReader 和 FileWriter 操作文本文件。
FileReader的使用
public class TestFileReader {public static void main(String[] args) throws IOException {//程序從文件中讀取內容，一個字符一個字符的// 有一個文件-----》創建一個File對象File file = new File("e:\\test\\test.txt");// 利用 FileReader 這個流，將“管子” 懟到源文件上去FileReader fileReader = new FileReader(file);// 利用管子，進行讀取的動作int n = fileReader.read(); //每次只能讀一個字符，如果到了文件的末尾，返回的值是-1；while (n != -1) {System.out.print((char) n); // 讀取的是Unicode碼，可以轉換為字符輸出n = fileReader.read();}System.out.println();//管子不用了，就把管子關閉; ----->手動關閉流fileReader.close();//程序從文件中讀取內容，多個字符多字符的// 有一個文件-----》創建一個File對象File file1 = new File("e:\\test\\test.txt");// 利用 FileReader 這個流，將“管子” 懟到源文件上去FileReader fileReader1 = new FileReader(file);// 利用管子，進行讀取的動作char[] chars = new char[5]; // 一次性讀取五個字符int read = fileReader1.read(chars); // 返回值是char數組的長度while (read >= chars.length) {System.out.print(chars);read = fileReader1.read(chars);}//管子不用了，就把管子關閉; ----->手動關閉流fileReader.close();} }FileWriter的使用
public class TestFileWriter {public static void main(String[] args) throws IOException {// 創建一個文件對象File file = new File("e:\\test\\test.txt");// 創建FileWriter對象，將管子懟到文件上去// 沒有文件會自動創建一個文件，如果有文件則會覆蓋文件，append如果設置為true，則不會覆蓋文件，而是在之前的文件后面進行追加。FileWriter fileWriter = new FileWriter(file, true);// 開始往外寫文件String str = "創建FileWriter對象,開始往外寫文件";// 一個字符一個字符的寫for (int i = 0; i < str.length(); i++) {fileWriter.write(str.charAt(i));}// // 直接往外寫// char[] chars = str.toCharArray();// fileWriter.write(chars);// 關閉流fileWriter.close();} }使用FileReader 和 FileWriter完成文件的復制。
public class TestFileReaderWriter {public static void main(String[] args) throws IOException {// 源文件File infile = new File("e:\\test\\test.txt");// 目標文件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);}// 關閉流 后用的先關閉fileWriter.close();fileReader.close();} }5、不能用字符流去操作非文本文件，否則得到的文件會不可用。
文本文件：.txt? .java .c .cpp 等，建議使用字符流去操作
非文件文件：.jpg .mp3等，建議使用字節流去操作。
6、FileInputStream 和 FileOutputStream 的使用
- 假設文件是UTF-8存儲的，那么英文占一個字節，中文占三個字節 --->因此文本文件就不建議用字節流讀取
- 如果一個字節一個字節的讀，那么 read方法底層做了處理，讓返回的數都是“正數”，為了避免返回-1的話，不知道是讀入的字節，還是文件的結尾。
- 如果用緩沖數組byte[]去讀,那么read的時候，字節就可以為負值，-128~127，因為判斷文件末尾用的是 “read的返回值是byte數組的有效長度=-1”，和字節本身不會沖突
- 如果用緩沖數組取寫，wirte的時候要注意長度，否則復制得到的文件會比源文件大（最后一個數組里面有些是無效內容）?fileOutputStream.write(byte，0，length); 寫入數組的第0位到底length位
7、緩沖字節流（處理流） BufferedInputStream/BufferedOutputStream 的使用
- 利用緩沖字節數組可以減少訪問硬盤的次數，提升效率，但是訪問次數還是較多，能不能進一步減少訪問硬盤次數呢？我們可以引入一個新的流 “緩沖字節流（處理流）”
- 其實BufferedInputStream/BufferedOutputStream底層也是通過新建緩沖數組進行數據操作的，size值為8192
- 如果數據流存在著嵌套，那么其實只要關閉高級流，那么里面的字節流也會隨之關閉。
例如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 {//程序從文件中讀取內容，一個字符一個字符的// 有一個文件-----》創建File對象File file = new File("e:\\test\\圖片.gif");File file2 = new File("e:\\test\\圖片2.gif");// 利用 FileInputStream FileOutputStream 這個流，將“管子” 把程序和源文件連接FileInputStream fileInputStream = new FileInputStream(file);FileOutputStream fileOutputStream = new FileOutputStream(file2);// 功能加強，引入新的流BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);// 開始動作 其實BufferedInputStream/BufferedOutputStream底層也是通過新建緩沖區數據操作的，size值為8192byte[] bytes = new byte[1026 * 8];int len = bufferedInputStream.read(bytes);while (len != -1) {bufferedOutputStream.write(bytes, 0, len);// bufferedOutputStream.flush();底層已經幫忙做了刷新緩沖區的操作，不需要手動完成刷新len = bufferedInputStream.read(bytes);}// 關閉流 ，倒著關閉// 如果數據流存在著嵌套，那么其實只要關閉高級流，那么里面的字節流也會隨之關閉。bufferedOutputStream.close();bufferedInputStream.close();// fileOutputStream.close(); 可以不寫// fileInputStream.close(); 可以不寫} }8、緩沖字符流（處理流） BufferedReader/BufferedWriter 的使用
public class TestBuffer02 {public static void main(String[] args) throws IOException {//程序從文件中讀取內容，一個字符一個字符的// 有一個文件-----》創建File對象File file = new File("e:\\test\\test.txt");File file2 = new File("e:\\test\\test1.txt");// 利用 FileInputStream FileOutputStream 這個流，將“管子” 把程序和源文件連接FileReader fileReader = new FileReader(file);FileWriter fileWriter = new FileWriter(file2);// 功能加強，引入新的流BufferedReader bufferedReader = new BufferedReader(fileReader);BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);// 開始動作 其實BufferedInputStream/BufferedOutputStream底層也是通過新建緩沖區數據操作的，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(); // 注意寫入時，每行之間要新加一行，否則復制的文件中沒有換行。str = bufferedReader.readLine();}// 關閉流 ，倒著關閉// 如果數據流存在著嵌套，那么其實只要關閉高級流，那么里面的字節流也會隨之關閉。bufferedWriter.close();bufferedReader.close();// FileWriter.close(); 可以不寫// FileReader.close(); 可以不寫} }9、轉換流（將字節流和字符流進行轉換）InputStreamReader / OutputStreamWriter的使用。
看后綴，這兩個轉換流屬于字符流。
- InputStreamReader：字節輸入流轉換為字符輸入流，完成文件到程序
- OutputStreamWriter：字符輸出流轉換為字節輸出流，完成程序到文件
10、System類對IO屬性的支持
- System.in：從鍵盤輸入
- System.out：輸出到控制臺
11、數據流DataInputStream / DataOutputStream
將文件中存儲的基本數據類型和字符串寫入到內存的變量中，但是讀的過程中，要注意變量的類型要和寫入變量的類型要一一對應，否則會讀出錯。
12、對象流 ObjectInputStream 和 ObjectOutputStream
用于存儲和讀取基本數據類型或者對象的處理流，他的強大之處就是可以把Java中的對象寫入到數據源中，也能把對象從數據源中還原回來。
ObjectOutputStream : 將一個對象轉化為字節寫到一個文件中去，以此來實現對象的持久化保存，這個過程被稱為序列化。
ObjectInputStream :?從文件中讀取被序列化的對象, 稱作反序列化。
序列化的可以參考以下鏈接
Java 反射reflect 序列化_材料小菜鳥的博客-CSDN博客
13、什么是同步，什么是異步？
同步：如果有多個任務或者事件要發生，這些任務或者事件必須逐個進行，一個事件任務的執行會導致整個流程的暫時等待，其他事件沒有辦法并發的執行下去；
異步：如果有多個任務或者事件要發生，那么這些事件可以并發的執行
例子：一個任務包括兩個子任務A和B，同步時，A執行過程中B只能等待，直到A執行完畢后,B才能繼續執行；異步時，AB可以并發的執行，B不用等待A執行結束。
14、什么是阻塞，什么是非阻塞？
阻塞：某個事件或者任務執行過程中，發出一個請求，但是由于該請求操作需要的條件不滿足而無法繼續執行時，他就一直在那等待，直到條件滿足后繼續執行；
非阻塞：某個事件或者任務執行過程中，發出一個請求，如果該請求操作需要的條件不滿足，會立即返回一個標志信息告知條件不滿足，不會一直等待。
舉個簡單的例子：
假如我要讀取一個文件中的內容，如果此時文件中沒有內容可讀，對于同步來說就是會一直在那等待，直至文件中有內容可讀；而對于非阻塞來說，就會直接返回一個標志信息告知文件中暫時無內容可讀。
阻塞和非阻塞著重點在于發出一個請求操作時，如果進行操作的條件不滿足是否會返會一個標志信息告知條件不滿足。理解阻塞和非阻塞可以同線程阻塞類比地理解，當一個線程進行一個請求操作時，如果條件不滿足，則會被阻塞，即在那等待條件滿足。
有關BIO/NIO/AIO的知識，后續學習完網絡相關的在來補充。
15、BIO（Bolcking IO）
同步阻塞IO，jdk1.4之前只有這一種IO模型，指的是調用發起后，會阻塞線程，直到獲得結果，服務端一個線程只能同時處理一個客戶端的請求。
問題：服務端在等待接收客戶端請求時阻塞，等待客戶端的連接，有多個客戶端連接時，由于client1先和服務端進行了連接，此時服務端只能處理client1 的請求，什么時候client1處理完，什么時候才可以處理其他的請求，此時client2發送請求，服務端是沒辦法處理的
TCP/IP底層使用的是BIO，同步阻塞IO，發起請求后，必須等待接收到響應后，代碼才能繼續向下執行，服務端一個線程只能處理一個客戶端的請求
解決方案：服務端為每個客戶端創建一個線程，但是如果客戶端特別多，服務器就需要創建對應數量的子線程，由于每個子線程都有自己的獨立線程區，子線程創建多了就會產生內存不足等問題，而且子線程也需要調度，切換和銷毀也都是非常消耗性能的。使用線程池可以一定程度上提升線程創建和銷毀的性能，但是調度和切換帶來的性能下降還是無法解決。
16、NIO?
new IO 或者 Non-Blocking IO，NIO的特性就是同步非阻塞IO；
調用發起后，等待獲得結果，但是不會阻塞線程，NIO中服務端的一個線程可以處理多個客戶端。
NIO解決了使用BIO服務端創建過多的子線程產生內存消耗、子線程調度切換銷毀等帶來的性能消耗問題。
NIO支持面向緩沖的，基于通道的I/O操作方法。 NIO提供了與傳統BIO模型中的?Socket?和?ServerSocket?相對應的?SocketChannel?和?ServerSocketChannel?兩種不同的套接字通道實現,兩種通道都支持阻塞和非阻塞兩種模式。阻塞模式使用就像傳統中的支持一樣，比較簡單，但是性能和可靠性都不好；非阻塞模式正好與之相反。對于低負載、低并發的應用程序，可以使用同步阻塞I/O來提升開發速率和更好的維護性；對于高負載、高并發的（網絡）應用，應使用 NIO 的非阻塞模式來開發。
17、Buffer緩沖區
Buffer緩沖區，緩沖區中緩存的是流數據，BIO直接操作流數據，NIO模型變為操作緩存區數據通過channel管道進行傳輸。
Buffer緩沖區是一個對象，他包含一些要寫入或者剛讀出的數據，緩沖區實質上是一個數組 ，NIO所有的數據都是用緩沖區處理，寫入數據時，首先寫到緩沖區中，讀數據也是從緩沖區中去讀。
Buffer的主要實現類
ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer
在NIO中，Buffer類是抽象類，是所有緩存的父類，提供了除boolean外基本數據類型的緩存類，但是我們一般只使用ByteBuffer，因為TCP協議是基于字節的，所以緩存區也使用的是Byte類型的緩存區
18、channel 通道
通道是對原IO包中流的一個模擬，源與目標的連接是借助一個Channel對象（通道）實現的，channel 不能直接訪問數據，需要和緩沖區進行交互 。
舉個栗子：
A和B兩個地區之間可以進行鐵路運輸，他們分別在火車站旁邊有個倉庫AB；這里的鐵路就是管道channel，而AB兩個倉庫就是緩沖區Buffer，倉庫用于臨時存儲運來的貨物，即緩沖區用于臨時存儲傳輸來的數據。
Channel的主要實現類
1 、FileChannel:用于讀取、寫入、映射和操作文件的通道。
2、 DatagramChannel:通過UDP讀寫網絡中的數據通道。
3 、SocketChannel:通過tcp讀寫網絡中的數據。
4 、ServerSocketChannel:可以監聽新進來的tcp連接，對每一個連接都創建一個SocketChannel。
其中FileChannel沒有繼承SelectableChannel， 因此不支持非阻塞操作；其他的類都支持非阻塞操作。
獲取通道的方式
1、通過getChannel()方法獲取
前提是該類支持該方法。支持該類的方法有：
FileInputStream/FileOutputStream，RandomAccessFile，Socket，ServerSocket ，DatagramSocket
2、通過靜態方法open（）
3、通過jdk1.7中Files的newByteChannel()方法
NIO的底層工作原理
首先Buffer的工作機制
1、buffer數組的幾個屬性設置
public abstract class Buffer {private int mark = -1; // 用于記錄當前 position 的前一個位置或者默認是 -1private int position = 0; // 下一個要操作的數據元素的位置private int limit; // 緩沖區數組中不可操作的下一個元素的位置 limit <=capacityprivate int capacity; // 緩沖區數組的長度 }2、初始化時，默認狀態為：
3、開始往數組中寫入字節的時候，變為下圖，position會移動到數據結束的下一個位置
?4、調用buffer.flip() 方法，byte數組中的內容不變，position賦值給limit，position重置為0； 適合讀之前的操作
public final Buffer flip() {limit = position;position = 0;mark = -1;return this;}?5、調用buffer.clear() 方法，byte數組中的內容不變，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中的源碼和網上的博客大多不一樣。
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) {// 方式一：創建byteBuffer對象，ByteBuffer是抽象類，使用allocate(capacity)方法給buffer分配緩存空間// 底層使用byte[]數組存儲緩存數據，數組的長度為傳入的參數capacityByteBuffer byteBuffer = ByteBuffer.allocate(1024);// 方式二：根據傳遞的內容自動創建緩存區大小，大小為內容的長度// ByteBuffer byteBuffer1 = ByteBuffer.wrap("hello,world".getBytes());// 向緩存區中放內容byteBuffer.put("hello".getBytes());// position 代表下一個存放位置的開始，初始為0System.out.println(byteBuffer.position()); // 5// 最大限制，就是capacitySystem.out.println(byteBuffer.limit()); //1024// 獲取到緩存區中存值的數組 byteBuffer.array();byte[] array = byteBuffer.array();System.out.println(new String(array)); //hello000000000000... 0代表空格// 這種方法要保證不能對position進行重置操作System.out.println(new String(array, 0, byteBuffer.position())); // hello// 重置buffer// byte數組中的內容不變，position重置為0，capacity賦值給limit，適合寫之前的操作byteBuffer.clear();// byte數組中的內容不變，position賦值給limit，position重置為0 適合讀之前的操作byteBuffer.flip();} }Selector簡介
selector一般被稱為選擇器，也稱為多路復用器。是Java NIO核心組件中的一個，用于檢查一個躲著多個NIO channel 通道的狀態是否處于可讀或者可寫。如此可以實現單線程管理多個channels，也就是單個線程管理多個網絡連接。
?
可選擇通道SelectableChannel?
- 判斷一個channel是否可以被selector復用，是判斷是否繼承了抽象類SelectableChannel，如果繼承了就可以被復用，否則就不能。?
- SelectableChannel 類提供了實現通道的可選擇性所需要的公共方法，FileChannel類沒有繼承SelectableChannel類，因此不是可選通道。
- 一個通道可以被注冊到多個選擇器上，但是對每個選擇器而言，只能注冊一次。通道和選擇器之間的關系，是使用注冊的方式完成。SelectableChannel可以被注冊到Selector對象上，注冊的時候，需要制定通道的那些操作是Selector感興趣的，如可讀，可寫等。
Channel注冊到Selector
選擇鍵?SelectionKey
Selector的使用
注意：與selector 一起使用時，channel必須處于非阻塞模式，否則將拋出異常IllegalBlockingModeExcption；因此FileChannel不能和selector一起使用，因為FileChannel不能切換到非阻塞模式，而套接字相關的通道都可以
一個通道并不是要支持所有四種操作，如服務器通道ServerSocketChannel支持ACCEPT操作，而SocketChannel不支持?？梢酝ㄟ^通道上的validOps()方法，獲取特定通道下支持的操作集合。
NIO實現服務端和客戶端的連接
服務端
/** 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 {// 創建TCP服務端的管道ServerSocketChannel ssc = ServerSocketChannel.open();// 默認管道是阻塞的，因此要手動設置為非阻塞模式ssc.configureBlocking(false);// 綁定對應的ip 端口號ssc.bind(new InetSocketAddress("127.0.0.1", 9999));// 創建選擇器（多路復用器）Selector selector = Selector.open();//將管道注冊到多路復用器上 --->參數1,多路復用器，參數2.多路復用器的監聽服務端接收客戶端的狀態（此時沒有狀態）// 如果接收到了客戶端，此時管道會變為該狀態ssc.register(selector, SelectionKey.OP_ACCEPT);while (true) {// 選擇管道的狀態 沒有狀態會阻塞，有狀態會繼續執行selector.select();System.out.println("------------------");// 獲取所有被監聽到的狀態Set<SelectionKey> selectionKeys = selector.selectedKeys();// 獲取迭代器，方便后續操作，當然也可以用foreach遍歷Iterator<SelectionKey> iterator = selectionKeys.iterator();while (iterator.hasNext()) {SelectionKey next = iterator.next();// 服務端接收到了客戶端，Accept狀態被監聽到if (next.isAcceptable()) {System.out.println(next.isAcceptable());SocketChannel accept = ssc.accept();// 這個管道是客戶端管道,可以理解是在服務端的這頭accept.configureBlocking(false);// 設置客戶端的管道在服務端這頭為非阻塞//System.out.println(accept);// 將客戶端管道注冊到多路復用器，監聽管道中內容的狀態accept.register(selector, SelectionKey.OP_READ);} else if (next.isReadable()) { // 管道中有數據// 可讀狀態時，獲取被選中的管道SelectableChannel sc = next.channel();// 通過客戶端管道接收數據,放入緩存中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);// 讀完之后監聽寫的狀態} else if (next.isWritable()) {Thread.sleep(1000);SelectableChannel sc = next.channel();// 服務端向客戶端發送數據((SocketChannel) sc).write(ByteBuffer.wrap("你好".getBytes()));sc.register(selector, SelectionKey.OP_READ); // 寫完之后監聽讀}// 去除已經被監聽到的狀態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 {// 創建客戶端管道SocketChannel sc = SocketChannel.open();// 設置為非阻塞sc.configureBlocking(false);// 創建多路復用器Selector selector = Selector.open();// 將客戶端管道注冊到多路復用器中sc.register(selector, SelectionKey.OP_CONNECT);// 連接服務端sc.connect(new InetSocketAddress("127.0.0.1", 9999));while (true) {// 選擇客戶端管道的狀態selector.select();// 獲取所有被監聽到的狀態Set<SelectionKey> selectionKeys = selector.selectedKeys();// 通過迭代器獲取所有被監聽到的狀態，方便后續操作Iterator<SelectionKey> iterator = selectionKeys.iterator();while (iterator.hasNext()) {SelectionKey next = iterator.next();//判斷客戶端是否連接了服務端,if (next.isConnectable()) {// 此時是掛起狀態，并沒有真正連接System.out.println(sc); // java.nio.channels.SocketChannel[connection-pending remote=/127.0.0.1:9999]// 讓客戶端管道掛起的狀態變成真正的鏈接狀態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]}// 向服務端輸出一句話ByteBuffer wrap = ByteBuffer.wrap("success".getBytes());sc.write(wrap);// 監聽客戶端管道中有數據的狀態sc.register(selector, SelectionKey.OP_READ);} else if (next.isReadable()) {// 通過客戶端管道接收數據,放入緩存中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); // 讀完監聽寫// 想服務端寫數據} else if (next.isWritable()) {Thread.sleep(1000);sc.write(ByteBuffer.wrap("nihao".getBytes()));sc.register(selector, SelectionKey.OP_READ);// 寫完監聽讀}}}} }Pipe管道
Java NIO管道是兩個線程之間的單向數據連接，Pipe中有一個source通道和一個sink通道，數據會被寫到sink通道中，然后從source通道中讀取。
創建管道 Pipe pipe = Pipe.open();
?
FileLock 文件鎖
文件鎖分類
- 排他鎖：又叫獨占鎖，對文件加排他鎖后，該進程可以對此文件進行讀寫操作，其他進程不能讀寫此文件，直到該進程釋放文件鎖。
- 共享鎖：某個進程對文件加共享鎖，其他進程也可以訪問該文件，但是都是只讀操作。
獲取文件鎖的方法
- lock() 對整個文件加鎖，默認排他鎖
- lock(long position, long size , boolean shared)? 自定義加鎖方式，前兩個參數指定加鎖的部分（可以只對此文件部分內容加鎖），第三個參數指定是否為共享鎖
- tryLock() 對整個文件加鎖，默認為排他鎖
- tryLock(long position, long size , boolean shared)? 自定義加鎖方式
lock和?tryLock 的區別：
- lock是阻塞式的，如果未獲取到文件鎖，會一直阻塞當前線程，直到獲取文件鎖
- tryLock是非阻塞式的，嘗試獲取文件鎖，獲取成功就返回鎖對象，失敗返回null，不會阻塞當前線程。
AIO?
Asynchronous IO:異步非阻塞IO，在執行時，當前線程不會阻塞，調用發起后，不需要等待返回結果（結果是以事件驅動的形式返回），而且也不需要多線程就可以實現多客戶端訪問。
AIO實現服務端和客戶端的連接
服務端
/** 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.AsynchronousServerSocketChannel; import java.nio.channels.AsynchronousSocketChannel; import java.nio.channels.CompletionHandler; import java.util.concurrent.CountDownLatch;public class TestAsynchronousSeverSocketChannel {public static void main(String[] args) throws IOException, InterruptedException {// 計數器// CountDownLatch await() ： CountDownLatch數組不等于0 的時候，阻塞// countDown(),調用一次，計數器的值-1CountDownLatch latch = new CountDownLatch(1);// 1 創建服務端AsynchronousServerSocketChannelAsynchronousServerSocketChannel assc = AsynchronousServerSocketChannel.open();// 2 綁定ip 和 端口號assc.bind(new InetSocketAddress("127.0.0.1", 9999));// 3 接收客戶端assc.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {// 接收成功執行該回調方法// 參數1： 客戶端的管道@Overridepublic void completed(AsynchronousSocketChannel result, Object attachment) {ByteBuffer allocate = ByteBuffer.allocate(1024);result.read(allocate, null, new CompletionHandler<Integer, Object>() {@Override // 成功接收到客戶端數據執行public void completed(Integer result, Object attachment) {System.out.println("連接成功");// 先獲取ByteBuffer中的數組byte[] array = allocate.array();// 數組轉為字符串String s = new String(array, 0, allocate.position());System.out.println(s);// 拿到數據，計數器減一latch.countDown();}@Override // 接收客戶端數據失敗執行public void failed(Throwable exc, Object attachment) {System.out.println("接收數據失敗");}});}// 接收失敗，執行該方法@Overridepublic void failed(Throwable exc, Object attachment) {System.out.println("接收失敗了");}});latch.await(); // 主線程等待} }客戶端
/** 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.AsynchronousSocketChannel; import java.nio.channels.CompletionHandler; import java.util.concurrent.CountDownLatch;public class TestAsynchronousSocketChannel {public static void main(String[] args) throws IOException, InterruptedException {CountDownLatch latch = new CountDownLatch(1);// 1 創建客戶端AsynchronousSocketChannel asc = AsynchronousSocketChannel.open();// 2 連接服務端asc.connect(new InetSocketAddress("127.0.0.1", 9999), null, new CompletionHandler<Void, Object>() {// 連接服務端成功，執行該方法@Overridepublic void completed(Void result, Object attachment) {System.out.println("連接成功");asc.write(ByteBuffer.wrap("你好".getBytes()));latch.countDown();}// 連接服務端失敗，執行該方法@Overridepublic void failed(Throwable exc, Object attachment) {System.out.println("連接失敗");}});// 3 阻塞主線程，直到向服務端發送了消息latch.await();} }總結
以上是生活随笔為你收集整理的Java - IO流学习笔记的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： win11提示找不到gpedit.msc
- 下一篇： Java剑开天门（二）