Java中的NIO详解Day03-缓存Buffer

一时失言乱红尘 2023-02-27 05:36 5阅读 0赞

### 缓存Buffer ###

*  Buffer的概念
 *  Buffer的基本用法
 *  Buffer的属性
 *   *   *  capacity
         *  position
         *   *   *  写数据
                 *  读数据
         *  limit
         *   *   *  写模式
                 *  读模式
 *  Buffer的类型
 *  Buffer分配
 *  Buffer写入数据
 *  Buffer的flip()方法
 *  Buffer读取数据
 *  Buffer的常用方法
 *   *   *  rewind()
         *  clear()和compact()
         *   *   *  clear()
                 *  compact()
         *  mark()和reset()
         *  equals()和compareTo()
         *   *   *  equals()
                 *  compareTo()

# Buffer的概念 #

*  **Java NIO**中的**Buffer**用于和**NIO**通道进行交互
    
     *  数据是从通道读入缓冲区
     *  数据是从缓冲区写入通道
 *  **缓冲区的本质:** 是一块可以写入数据,然后可以从中读取数据的内存
    
     *  这块内存被包装成**NIO Buffer**对象
     *  提供了一组方法,用来方便访问该块内存

# Buffer的基本用法 #

*  **Buffer**读写数据的步骤:
    
     *  **写入数据到Buffer**
     *  **调用flip()方法**
     *  **从Buffer中读取数据**
     *  **调用clear()或者compact()方法**
 *  **Buffer的工作流程:**
    
     *  当向Buffer写入数据时,Buffer会记录写下多少数据
     *  一旦需要读取数据,需要通过**flip()** 方法从写模式切换到读模式
     *  在读模式下,可以读取之前写入到Buffer的所有数据
     *  一旦读完了所有数据,就要清空缓冲区,让缓冲区可以再次被写入
     *  清空缓冲区有两种方式:
        
         *  **clear():** 清空整个缓冲区
         *  **compact():** 只清除已经读过的数据. 任何未读的数据都会被移到缓冲区的起始处,新写入的数据将会放到缓冲区未读数据的后面位置
 *  **Buffer使用示例:**

RandomAccessFile file = new RandomAccessFile("data/nio-data.txt", "rw");
    FileChannel channel = file.getChannel();
    
    ByteBuffer buffer = ByteBuffer.allocate(64);
    
    int bytesRead = channel.read(buffer);
    
    while (bytesRead != -1) { 
    	buffer.flip();
    	while(buffer.hasRemaining()) { 
    		System.out.print((char)buffer.get());
    	}
    	buffer.clear();
    	bytesBuffer = channel.read(buffer); 
    }
    file.close();

# Buffer的属性 #

*  缓冲区本质上是一块可以写入数据,然后可以从中读取数据的内存
    
     *  这块内存被包装成**NIO Buffer**对象,并提供了一组方法,用来方便访问该块内存
 *  **Buffer的三个属性:** position和limit的含义取决于Buffer处于读模式还是写模式. capacity的含义总是一样的
    
     *  **capacity**
     *  **position**
     *  **limit**  
        ![在这里插入图片描述][format_png_pic_center]

### capacity ###

*  作为一个内存块 **,Buffer**有一个固定大小的值,叫作**capacity**
 *  只能往**Buffer**中写**capacity**个**byte,long,char**等类型的值
 *  一旦**Buffer**满了,通过读数据或者清除数据将**Buffer**清空,才能继续往里写数据

### position ###

##### 写数据 #####

*  当写数据到**Buffer**中时 **,position**表示当前的位置
 *  初始**position**的值为**0,** 当一个**byte,long**等数据写到**Buffer**后 **,position**会向前移动到下一个可插入数据的**Buffer**单元
 *  **position**最大可为**capacity-1**

##### 读数据 #####

*  当读数据时,从某个特定的位置读
 *  当从**Buffer**的**position**处读取数据时 **,position**向前移动到下一个可读的位置

### limit ###

##### 写模式 #####

*  **Buffer**的**limit**表示最多能往**Buffer**里写多少数据
 *  **limit**等于**Buffer**的**capacity**

##### 读模式 #####

*  当切换**Buffer**到读模式时,**limit**表示从**Buffer**中最多能读到多少数据
 *  因此,当切换**Buffer**到读模式时, **limit**会被设置成写模式下的**position**值. **limit**会被设置写模式下的**position**值.也就是说,能够读取到之前写入的所有数据

# Buffer的类型 #

*  **Java NIO**有以下**Buffer**类型:
    
     *  **ByteBuffer**
     *  **MappedByteBuffer**
     *  **CharBuffer**
     *  **DoubleBuffer**
     *  **FloatBuffer**
     *  **IntBuffer**
     *  **LongBuffer**
     *  **ShortBuffer**
 *  这些**Buffer**类型代表了不同的数据类型.也就是说,可以通过**char,short,int,long,float**或者**double**类型来操作缓冲区中的字节

# Buffer分配 #

*  要想获得一个**Buffer**对象首先要进行分配
 *  每一个**Buffer**都有一个**allocate()** 方法
 *  **示例:** 分配一个**64**字节**capacity**的**ByteBuffer**

ByteBuffer buf = ByteBuffer.allocate(64);

# Buffer写入数据 #

*  写数据到**Buffer**中有两种方式:
    
     *  从**Channel**中写到**Buffer**:
    
        int bytesRead = inChannel.read(buf);
    
     *  使用**Buffer**的**put()** 方法写到**Buffer**:
    
        /* * put()方法有多个具体实现 * 允许以不同的方式将数据写入到Buffer中 * 比如:写到一个指定的位置或者将一个字节数组写入到Buffer中 */
        	buf.put(128);

# Buffer的flip()方法 #

*  **flip()** 方法将**Buffer**从写模式切换到读模式
 *  调用**flip()** 方法会将**position**设回**0.** 并将**limit**设置为之前**position**的值
    
     *  **position:** 在读模式中,标记读的位置
     *  **limit:** 表示在写模式时写进了多少个**byte,char**等,在读模式时能读取多少个**byte,char**等

# Buffer读取数据 #

*  从**Buffer**中读取数据有两种方式:
    
     *  从**Buffer**读取数据到**Channel**:
    
        int bytesWritten = inChannel.write(buf);
    
     *  使用**Buffer**的**get()** 方法从**Buffer**中读取数据:
    
        /* * get()方法有多个具体实现 * 允许以不同的方式从Buffer中读取数据 * 比如:从指定的position读取或者从从Buffer中读取数据到字节数组 */
        	byte byte = buf.get();

# Buffer的常用方法 #

### rewind() ###

*  **Buffer**的**rewind()** 方法将**position**设回**0,** 这样可以重读**Buffer**中的所有数据
 *  **limit**保持不变,表示能从**Buffer**中读取多少个**byte,char**等元素

### clear()和compact() ###

*  如果读取完**Buffer**中的数据,需要让**Buffer**准备好再次写入.通过**clear()** 或者**compact()** 方法来实现

##### clear() #####

*  如果调用**clear()** 方法 **,position**将被设回**0,limit**将被设置成为**capacity**的值
 *  **clear()** 方法清空**Buffer,** 但是**Buffer**中的数据并没有被清除.只是这些标记表明从哪里开始向**Buffer**中写数据
 *  如果**Buffer**中存在未读的数据时,调用**clear()** 方法,这些数据将会**被遗忘.** 不再有任何标记哪些数据被读过,哪些数据未被读过

##### compact() #####

*  如果**Buffer**中存在未读的数据,且后续还需要这些数据,但是此时想要先写入数据,这时就可以使用**compact()** 方法
 *  **compact()** 方法将所有未读数据拷贝到**Buffer**的起始处.将**position**设置到最后一个未读元素的正后面,将**limit**设置成为**capacity**
 *  使用**compact()** 方法后的**Buffer**写数据时,不会覆盖未读的数据

### mark()和reset() ###

*  通过调用**Buffer.mark()** 方法,可以标记**Buffer**中的一个特定的**position**
 *  标记后,可以通过**Buffer.reset()** 方法恢复到这个**position**

### equals()和compareTo() ###

##### equals() #####

*  两个**Buffer**相等的条件:
    
     *  **有相同的类型.** 比如byte,char,int
     *  **Buffer**中剩余的**byte,char**等元素个数相等
     *  **Buffer**中所有剩余的**byte,char**等元素都相同
 *  **equals()** 只是比较**Buffer**的一部分,不是**Buffer**的每一个元素都比较.只会比较**Buffer**中的剩余元素,也就是从**position**到**limit**之间的元素

##### compareTo() #####

*  **compareTo()** 方法比较两个**Buffe**r的剩余的**byte,char**等元素,也就是从**position**到**limit**之间的元素
 *  一个**Buffer**小于另一个**Buffer**的条件:
    
     *  第一个不相等的元素小于另一个**Buffer**中对应的元素
     *  所有的元素都相等,但是第一个**Buffer**的元素个数比另一个少

[format_png_pic_center]: /images/20230209/67522ae5ffaf4383b4c959a4fc212d58.png