NIO之Buffer

首页 > 代码库 > NIO之Buffer

2024-07-02 06:14:55 227人阅读

Buffer

Mark<=Position <=Limt<=Capacity

状态变量

position:

在从通道读取时，将所读取的数据放到底层的数组中。 position 变量跟踪已经写了多少数据。它指定了下一个字节将放到数组的哪一个元素中。因此，如果从通道中读三个字节到缓冲区中，那么缓冲区的position 将会设置为3，指向数组中第四个元素。

mark：

一个备忘标记位置调用，mark()函数设置mark=positon,调用reset()设置position=mark。

limit

limit 变量表明还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)。

capacity

缓冲区的 capacity 表明可以储存在缓冲区中的最大数据容量。实际上，它指定了底层数组的大小或者指定了准许使用的底层数组的容量。

图形演示

初始：一个新创建的缓冲区。假设这个缓冲区的总容量为8个节。 Buffer 的状态如下所示：

读入缓冲区：写入5个字节。Buffer 的状态如下所示：

flip():它将设置limit为它将设置position为0；它将设置position为0；可以读缓冲区的内容了：

写入通道

第一次写入时，从缓冲区中取四个字节并将它们写入输出通道。这使得 position 增加到 4，而 limit 不变：

再次写入，只剩下一个字节可写， limit在调用 flip() 时被设置为 5，并且 position 不能超过 limit。所以最后一次写入操作从缓冲区取出一个字节并将它写入输出通道。这使得 position 增加到 5，并保持 limit 不变。

clear

它将limit设置为与capacity 相同;它设置 position为0;可以再次往缓冲区写数据了。

缓冲区操作

分配

/**
     * 分配缓冲区
     */
    @Test
    public void allocateBuffer(){
        ByteBuffer bf=ByteBuffer.allocate(1024);
        System.out.println("position:"+bf.position());
        System.out.println("limit:"+bf.limit());
        System.out.println("capacity:"+bf.capacity());
    }

运行结果：

包装

/**
     * 将原有数组包装成一个缓冲区。
     */
    public void wrapBuffer(){
        int [] ints={1,2,3,4,5};
        IntBuffer ib=IntBuffer.wrap(ints);
        ib.put(1,8);
        System.out.println(Arrays.toString(ints));
    }

运行结果：

数组和缓冲区共用一分数据。

分片

@Test
    public void sliceBuffer() {
        IntBuffer ib = IntBuffer.allocate(10);
        for(int i=0;i<10;i++){
            ib.put(i);
        }
        ib.position(3);
        ib.limit(6);
        IntBuffer sliceBuf=ib.slice();
        System.out.println("before slice:"+Arrays.toString(sliceBuf.array()));
        for(int j=0;j<sliceBuf.capacity();j++){
            sliceBuf.put(j,sliceBuf.get()*3);
        }
        System.out.println("after slice:"+Arrays.toString(sliceBuf.array()));
        System.out.println("old buffer"+Arrays.toString(sliceBuf.array()));
    }

运行结果：

原缓冲区和新的缓冲区分片共享同一个底层数据数组，并且对缓冲区分片的新缓冲区修改只影响子缓冲区。

压缩

@Test
     public void compactBuffer() {
        CharBuffer cb = CharBuffer.allocate(15);
        for (int i = 65; i < 75; i++) {
            cb.put((char) i);
        }
        cb.flip();
        System.out.println("original buffer:"+Arrays.toString(cb.array()));
        System.out.println("original positon:"+cb.position());
        System.out.println("original limit:"+cb.limit());
        for(int j=0;j<6;j++){
            cb.get();
        }
        System.out.println("after get position:"+cb.position());
        cb.compact();
        System.out.println("after compact position:"+cb.position());
        System.out.println("after compact limit:"+cb.limit());
        System.out.println("after compact buffer:"+Arrays.toString(cb.array()));
        cb.flip();
        System.out.println("after flip position:"+cb.position());
        System.out.println("after flip limit:"+cb.limit());
    }

运行结果：

未读的元素移动到下表0开始，position为最后一个未读元素的下一个下标，limit在这个过程中没变化，如果想读取这部分元素，执行一次翻转。

比较

　　两个缓冲区相等的充分必要条件：

两个缓冲区类型必须相同
两个缓冲区剩余元素数量必须相同，两个缓冲区容量可以不同

　　3. 两个缓冲区通过get()取得的元素序列必须相同

@Test
    public void compareBuffer(){
        //cb1和cb2的capacity不相等
        CharBuffer cb1=CharBuffer.allocate(10);
        CharBuffer cb2=CharBuffer.allocate(8);
        for (int i=65;i<75;i++){
            cb1.put((char)i);
        }
        for (int j=69;j<75;j++){
            cb2.put((char)j);
        }
        cb1.flip();
        cb2.flip();
        System.out.println("original cb1:"+Arrays.toString(cb1.array()));
        System.out.println("original cb2:"+Arrays.toString(cb2.array()));
        //cb1读取六个元素
        for(int m=0;m<5;m++){
           cb1.get();
        }
        //cb2读取一个元素
        cb2.get();
        System.out.println(cb1.equals(cb2));
    }

运行结果：

只读缓冲区

public void readOnlyBuffer() {
        IntBuffer ib = IntBuffer.allocate(10);
        for (int i = 0; i < 10; i++) {
            ib.put(i);
        }
        System.out.println("original buffer:"+Arrays.toString(ib.array()));
        IntBuffer readOnlyBuffer=ib.asReadOnlyBuffer();
        readOnlyBuffer.flip();
        //以下语句会接收异常：ReadOnlyBufferException。
        //System.out.println("readonly buffer:"+Arrays.toString(readOnlyBuffer.array()));
        System.out.print("original readonly buffer:");
        for (int j=0;j<readOnlyBuffer.capacity();j++){
            System.out.print(readOnlyBuffer.get());

        }
    }

只读缓冲区会和原缓冲区公用一分数据。

直接缓冲区

给定一个直接字节缓冲区，Java 虚拟机将尽最大努力直接对它执行本机 I/O 操作。也就是说，它会在每一次调用底层操作系统的本机 I/O 操作之前(或之后)，尝试避免将缓冲区的内容拷贝到一个中间缓冲区中(或者从一个中间缓冲区中拷贝数据)

/**
     * 直接缓冲区
     * @throws Exception
     */
    @Test
    public void directBuffer() throws Exception {
        FileInputStream fi = new FileInputStream(this.sourcePath);
        FileOutputStream fo = new FileOutputStream(this.destPath);
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);
        FileChannel fic = fi.getChannel();
        FileChannel foc = fo.getChannel();
        while (fic.read(directBuffer) != -1) {
            directBuffer.flip();
            foc.write(directBuffer);
            directBuffer.clear();
        }
        fi.close();
        fo.close();
    }

内存映像

内存映射文件 I/O 是通过使文件中的数据出现为内存数组的内容来完成的。一般来说，只有文件中实际读取或者写入的部分才会送入（或者映射）到内存中。

只能通过FileChannel来创建。

代码实例：

public void mappedByteBuffer() throws  Exception{
        FileInputStream fi = new FileInputStream(this.sourcePath);
        //MappedByteBuffer是ByteBuffer的子类。
        MappedByteBuffer mappedByteBuffer=fi.getChannel().map(FileChannel.MapMode.READ_ONLY,0l,1024l);

    }

字节缓冲区

字节顺序

大端字节

2. 小端字节

取决于硬件设计，JVM默认是大端字节，IP协议使用大端的网络字节顺序。
JVM对字节顺序的支持：ByteOrder

获取本地字节顺序：ByteOrder.nativeOrder();

 /**
     * 字节顺序
     */
    @Test
    public void byteOrder(){
        System.out.println("My mac pro byte order:"+ByteOrder.nativeOrder());
    }

运行结果：

视图缓冲区

/**
     * 视图buffer
     */
    @Test
    public void viewBuffer() {
        this.byteOrder();
        ByteBuffer bb = ByteBuffer.allocate(16).order(ByteOrder.BIG_ENDIAN);
        CharBuffer cb=bb.asCharBuffer();
        bb.put((byte)0);
        bb.put((byte)‘r‘);
        bb.put((byte)0);
        bb.put((byte)‘e‘);
        bb.put((byte)0);
        bb.put((byte)‘q‘);
        bb.put((byte)0);
        bb.put((byte)‘u‘);
        bb.put((byte)0);
        bb.put((byte)‘e‘);
        bb.put((byte)0);
        bb.put((byte)‘l‘);
        bb.put((byte)0);
        bb.put((byte)‘q‘);
        bb.put((byte)0);
        bb.put((byte)‘i‘);
        System.out.println("original bb position:"+bb.position()+",limit:"+bb.limit()+",bb is:"+Arrays.toString(bb.array()));
        System.out.println("view buffer cb position:"+cb.position()+",limit:"+cb.limit()+",bb is:"+cb.toString());
    }

运行结果：

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > NIO之Buffer

NIO之Buffer

Buffer

Buffer

状态变量

图形演示

缓冲区操作

只读缓冲区

直接缓冲区

内存映像

字节缓冲区

视图缓冲区

看完仍有疑问？有类似问题直接问程序猿