NIO--BUFFER 学习笔记

BUFFER简介

Buffer(缓冲区)本质上是一块可以写入数据，然后可以从中读取数据的内存。

在NIO库中，所有数据都是用缓冲区处理的。

从Buffer中读写数据，一般遵循以下四个步骤：

1. 写入数据到Buffer
2. 调用flip()方法--更改Buffer读写模式
3. 从Buffer中读取数据
4. 调用clear()方法或者compact()方法--清楚Buffer缓冲区内容

当向 buffer 写入数据时，buffer 会记录下写了多少数据。一旦要读取数据，需要通过 flip()方法将 Buffer 从写模式切换到读模式。在读模式下，可以读取之前写入到 buffer 的所有数据。一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有 两种方式能清空缓冲区：调用 clear()或 compact()方法。clear()方法会清空整个缓冲 区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起 始处，新写入的数据将放到缓冲区未读数据的后面

使用Buffer的两个例子

package Buffer;

import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.channels.FileChannel;

public class BufferDemo1 {

    //ByteBuffer
    @Test
    public void buffer01() throws Exception {
        //创建一个FileChannel
        RandomAccessFile accessFile = new RandomAccessFile("1.txt","rw");
        FileChannel channel = accessFile.getChannel();

        ByteBuffer byteBuffer = ByteBuffer.allocate(48);
        byteBuffer.clear();
        int read = channel.read(byteBuffer);
        while (read!=-1){
            byteBuffer.flip();
            while (byteBuffer.hasRemaining()){
                System.out.println((char)byteBuffer.get());
            }
            byteBuffer.clear();

            read = channel.read(byteBuffer);
        }
        channel.close();
    }

    //IntBuffer
    @Test
    public void IntBuffer() throws FileNotFoundException {
        IntBuffer intBuffer = IntBuffer.allocate(20);
        intBuffer.put(1);
        intBuffer.put(2);
        intBuffer.put(3);
        intBuffer.put(4);
        intBuffer.clear();
        while (intBuffer.hasRemaining()){
            System.out.println(intBuffer.get());
        }
    }
}

 理解Buffer的capacity、position和limit

1. capacity: 表示Buffer的最大容量
2. position:读模式：
   • 写模式：position表示写入数据的当前位置，position的初始值为0。当一个 byte、long 等数据写到 Buffer 后， position 会向下移动到下一个可插入 数据的 Buffer 单元。position 最大可为 capacity – 1（因为 position 的初始值为 0）
   • Buffer.flip()切换到读模式时，position会被重置为0，当Buffer从position读入数据后，position会移到下一个可读入的数据Buffer单元。
3. limit
   • 写数据：limit表示可对Buffer最多写入多少个数据。写模式下，limit等于capacity。
   • 读数据：limit表示Buffer里有多少可读数据

 Buffer的缓冲区操作

缓冲区分片

根据现有的缓冲区对象来创建一个子缓冲区，利用slice方法，子缓冲区相当于是现有缓冲区的一个试图窗口。改变子缓冲区中的内容，父缓冲区的内容也会改变

 

    //缓冲区切片
    @Test
    public void b1Test(){
        ByteBuffer byteBuffer = ByteBuffer.allocate(10);
        for (int i=0;i<byteBuffer.capacity();i++){
            byteBuffer.put((byte) i);
        }
        byteBuffer.position(3);
        byteBuffer.limit(7);
        ByteBuffer slice = byteBuffer.slice();
        for (int i=0;i<slice.capacity();i++){
            slice.put(i, (byte) (slice.get(i)*10));
        }
        byteBuffer.position(0);
        byteBuffer.limit(byteBuffer.capacity());
        while (byteBuffer.remaining()>0){
            System.out.println(byteBuffer.get());
        }
    }

只读缓冲区

只读缓冲区，顾名思义，可以读取但是不可以操作，可以通过调用asReadOnlyBuffer()方法，将任何一个缓冲区转换为只读缓冲区，这个返回一个与原缓冲区完全相同的缓冲区，并于原缓冲区共享数据，原缓冲区的内容改变，只读缓冲区的内容跟着改变

 如果尝试修改只读缓冲区的内容，则会报 ReadOnlyBufferException 异常。只读缓冲 区对于保护数据很有用。在将缓冲区传递给某个 对象的方法时，无法知道这个方法是 否会修改缓冲区中的数据。创建一个只读的缓冲区可以保证该缓冲区不会被修改。只 可以把常规缓冲区转换为只读缓冲区，而不能将只读的缓冲区转换为可写的缓冲区

@Test
    //只读缓冲区
    public void OnlyReadBufferTest(){
        ByteBuffer buffer = ByteBuffer.allocate(20);
        for (int i = 0; i < buffer.capacity();i++) {
            buffer.put((byte) i);
        }
        ByteBuffer byteBuffer = buffer.asReadOnlyBuffer();
        for (int i = 0; i < buffer.capacity(); i++) {
            buffer.put(i,(byte) (i*10));
        }
        byteBuffer.position(0);
        byteBuffer.limit(byteBuffer.capacity());
        while (byteBuffer.remaining()>0){
            System.out.println(byteBuffer.get());
        }
    }

直接缓冲区

直接缓冲区是为加快 I/O 速度，使用一种特殊方式为其分配内存的缓冲区，JDK 文档 中的描述为：给定一个直接字节缓冲区，Java 虚拟机将尽最大努力直接对它执行本机 I/O 操作。也就是说，它会在每一次调用底层操作系统的本机 I/O 操作之前(或之后)， 尝试避免将缓冲区的内容拷贝到一个中间缓冲区中 或者从一个中间缓冲区中拷贝数据。 要分配直接缓冲区，需要调用 allocateDirect()方法，而不是 allocate()方法，使用方 式与普通缓冲区并无区别。

@Test
    //直接缓冲区
    public void DirectBufferTest() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("1.txt");
        FileChannel channel = fileInputStream.getChannel();

        FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
        FileChannel channel1 = fileOutputStream.getChannel();

        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);

        while (true){
            byteBuffer.clear();
            int read = channel.read(byteBuffer);
            if (read==-1){
                break;
            }
            byteBuffer.flip();
            channel1.write(byteBuffer);
        }

    }

内存映射文件IO

 内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通 道的 I/O 快的多。内存映射文件 I/O 是通过使文件中的数据出现为 内存数组的内容来 完成的，这其初听起来似乎不过就是将整个文件读到内存中，但是事实上并不是这样。 一般来说，只有文件中实际读取或者写入的部分才会映射到内存中