Java NIO 中Buffer 缓冲区解析

目录
  • 一、Buffer 简介
  • 二、Buffer 的基本方法
    • 1、使用 Buffer 读写数据
    • 2、使用 Buffer 的例子
  • 三、Buffer 的 capactity、posittion 和limit
  • 四、Buffer 的类型
  • 五、Buffer 分配和写数据
    • 1、 Buffer 分配
    • 2、向 buffer 中写数据
    • 3、flip() 方法
  • 六、从 Buffer 中读取数据
  • 七、Buffer 几个方法
    • 1、rewind() 方法
    • 2、clear() 与 compact() 方法
    • 3、mark() 与 reset() 方法
  • 八、缓冲区操作
    • 1、缓冲区分片
    • 2、只读缓冲区
    • 3、直接缓冲区
    • 4、内存映射文件 I/O

一、Buffer 简介

Java NIO 中的 Buffer 用于和 NIO 通道进行交互。数据是通道读取到缓冲区

缓冲区本质上是一块可以写入数据,然后可以从中读取数据的内存。这块内存被包装 NIO Buffer 对象,并且提供了一组方法,用来方便的访问这块内存。缓冲区世纪上一个容器对象,更直接的说,其实就是一个数组,在 NIO 库中,所有数据都是用缓冲区处理的。 在读取数据时,它直接读到缓冲区中;在写数据时,它也是写入到缓冲区中的;任何时候访问 NIO 中的数据,都是将它放到缓冲区中。而在面向流 I/O 系统中,所有数据都是直接写入或者直接将数据读取到 Stream 对象中。

在 NIO 中,所有的缓冲区类型都是继承于抽象类 Buffer, 最常用的就是 ByteBuffer. 对于 Java 中国呢的基本类型,金额都有一个具体 Buffer 类型与之对应,他们之间的继承关系如下图所示:

二、Buffer 的基本方法

1、使用 Buffer 读写数据

使用 Buffer 读写数据,一般遵循以下四个步骤:

(1)写数据到 Buffer

(2)调用flip() 方法

(3)从 Buffer 中读取数据

(4)调用 clear() 方法或者 compact() 方法

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

2、使用 Buffer 的例子

@Test
public void buffer01() throws IOException {
    // FileChannel
    String pathName = "/Users/zhengsh/sourcecode.io/zhengsh-vvip/nio/src/main/resources/01.txt";
    RandomAccessFile accessFile =
        new RandomAccessFile(pathName, "rw");
    FileChannel channel = accessFile.getChannel();

    // 创建 buffer , 大小
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // 读
    int bytesRead = channel.read(buffer);
    while (bytesRead != -1) {
        // read 模式
        buffer.flip();

        while (buffer.hasRemaining()) {
            System.out.println((char) buffer.get());
        }
        buffer.clear();

        channel.read(buffer);
    }

    accessFile.close();
}

@Test
public void buffer02() {

    // 创建 buffer
    IntBuffer buffer = IntBuffer.allocate(8);
    for (int i = 0; i < buffer.capacity(); i++) {
        int j = 2 * (i + 1);
        buffer.put(j);
    }

    // 重置缓冲区
    buffer.flip();

    while (buffer.hasRemaining()) {
        int value = buffer.get();
        System.out.println(value + "  ");
    }
}

三、Buffer 的 capactity、posittion 和limit

为了理解 Buffer 的工作原理,需要熟悉它的三个属性:

  • capacity
  • ponstition
  • limit

position limit 的含义取决于 Buffer 处在读模式还是写模式。不管 buffer 处于什么模式,capactity 的含义总是一样的。

这里有一个关于 capacity, postition 和 limit 在读模式中的说明:

(1) capactiy

作为一个内存块,Buffer 有一个固定的大小值,也叫做 “capactiy” . 你只能往里面写 capacity 个 byte

long、 char等类型。一旦 buffer 满了,需要将其清空(通过读数据或者清除数据)才能继续写数据往里写数据。

(2) postition

1)写数据到 Bufer 中时,position 表示写入数据的当前位置,position 的初始值为 0 。当一个 byte,long,等数据写入到 buffer 后,position 会向下移动到下一个可插入的元素的 buffer 但愿。position 最大可为 capacity -1 (因为 position 的初始值为 0)

2)读数据到 Buffer 中时,position 表示读数据的当前位置,如 position = 2 时表示已经开始读了 3 个 byte, 或者从第三个 byte 开始读取,通过 ByteBuffer.flip() 切换到读模式 position 会被重置为 0, 当 Buffer 从 position 读入数据后,position 会下移到下一个可读入的数据 Buffer 单元。

(3) limit

1)写数据时, limit 表示可以对 Buffer 最多写入多少个数据。写模式下,limit 等于 Buffer 的 capactiy

2)读数据时, limit 表示 Buffer 里有多少可读数据(not null 的数据),因此能读取到之前写入的所有数据(limit 被设置为已写数据的数量,这个值在写模式下就是 position)

四、Buffer 的类型

Java NIO 有一下 Buffer 的类型

  • ByteBuffer
  • MappedByteBuffer
  • CharBuffer
  • DoubleBuffer
  • FloatBuffer
  • LongBuffer
  • ShortBuffer

这些 buffer 类型都代表了不同的数据类型。换句话说,就是可以通过 char ,short, int, long , float 或者 double 类型来操作缓冲区的字节。

五、Buffer 分配和写数据

1、 Buffer 分配

想要获取一个 Buffer 对象首先要进行分配。每一个 Buffer 类都有一个 allocate 方法。

下面是一个分配 48 字节 capactiy 的 ByteBuffer 的例子。

ByteBuffer buf = ByteBuffer.alloacte(48);

这是分配一个可存储 1024 个字符的 CharBuffer:

ByteBuffer buf = ByteBuffer.alloacte(1024);

2、向 buffer 中写数据

写数据到 Buffer 有两种方式:

  • (1)从 channel 写到 Buffer
  • (2)通过 Buffer 的 put 方法写到 Buffer 里。

从 Channel 写到 Buffer 的例子

int byteRead = channel.read(buf); // read into buffer

通过 put 方法写入 buffer 的例子:

buf.put(100);

put 的方法有很多版本,允许你不同的方式把数据写入到 buffer 中,例如,写到一个指定的位置,或者把字节数组写入到 Buffer .

3、flip() 方法

flip 方法将 Buffer 从写模式切换到读模式。调用 flip() 方法将会 position 设置为 0 , 并且将 limt 设置为之前 position 的值。换句话说,position 现在用于标记读的位置,limit 表示之前写进了多少个 byte, char 等(现在能读取多少个 byte, char 等)。

六、从 Buffer 中读取数据

从 Buffer 中读取数据到 Channel 中:

(1) 从 Buffer 中读取数据到 Channel

(2)使用 get 方法从 Buffer 中读取数据

从 Buffer 中读取数据到 Channnel 到例子:

// read form buffer into channel 
int bytesWritten = inChannel.write(buf);

使用 get() 方法从 Buffer 中读取数据的例子:

byte aByte = buf.get();

get 方法中有很多版本,允许你以不同的方式 Buffer 中读取数据。例如,从指定 position 读取,或者从 Buffer 中读取到字节数组。

七、Buffer 几个方法

1、rewind() 方法

Buffer.rewind() 将 position 返回0, 所以你可以重读 Buffer 中的所有数据。limit 保持不变,仍然表示能从 Buffer 中读取到多少个元素(byte, char 等)。

2、clear() 与 compact() 方法

一旦读完 Buffer 中的数据,需要让 Buffer 准备好再次被写入。可以通过 clear() 或 compact() 方法来完成

如果调用的是 cleanr () 方法,position 兼备设置为 0 , limit 被设置成 capactiy 的值。换句话说,Buffer 被清空了。 Buffer 中的数据并未清除,只是这些标记高数我们从哪里开始往 Buffer 中写数据。

如果 Buffer 中有些数未读的数据,调用 clear() 方法,数据将 “被遗忘”,意味着不在有任何标记会告诉你那些数据被读过,那些还没有。

如果 Buffer 中依然有未读的数据,且后续还需要这些数据,但是此时想要先写这些数据,那么使用 compact() 方法。

compact() 方法将所有未读的数据拷贝到 Buffer 起始处。然后将 position 设置到最后一个未读元素正后面。 limit 属性依然像 clear() 方法一样。设置成 capacity. 现在 Buffer 准备好写数据了,但是不会覆盖未读的数据。

3、mark() 与 reset() 方法

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

buffer.mark();

// call buffer.get() a couple of times, e.g. during parsing  
buffer.reset(); // set position back to mark

八、缓冲区操作

1、缓冲区分片

在 NIO 中除了可以分配或者包装一个缓冲区对象外,还可以更具现有的缓冲区对象来创建一个子缓冲区,即现有缓冲区上切出一片来作为一个新的缓冲区,但现有的缓冲区与创建的子缓冲区在底层数组层面上是数据共享的,也就是说,子缓冲区相当于是现有缓冲区的一个视图窗口。调用 slice() 方法可以创建一个子缓冲区。

// 缓冲区分片
@Test
public void b01() {
    ByteBuffer buffer = ByteBuffer.allocate(10);
    // 放入数据
    for (int i = 0; i < buffer.capacity(); i++) {
        buffer.put((byte) i);
    }

    // 创建子缓冲区
    buffer.position(3);
    buffer.limit(7);
    ByteBuffer slice = buffer.slice();

    // 改变子缓冲区中的内容
    for (int i = 0; i < slice.capacity(); i++) {
        byte b = slice.get(i);
        b *= 10;
        slice.put(i, b);
    }

    // 复位
    buffer.position(0);
    buffer.limit(buffer.capacity());

    while (buffer.remaining() > 0) {
        System.out.println(buffer.get());
    }
}

输出结果如下:

2、只读缓冲区

只读缓冲区非常简单,可以读取他们,但是不能向他们写入数据。可以通过调用缓冲区的 asReadOnlyBufer() 方法,将任何常规缓冲区转换为只读缓冲区,这个方法返回一个与原缓冲区完全相同的缓冲区,并与原缓冲区共享数据,只不过它是只读的。如果原缓冲区的内容发生了变化,只读缓冲区的内容随之发生变化:

// 只读缓冲区
@Test
public void b02() {
    ByteBuffer buffer = ByteBuffer.allocate(10);

    // 放入数据
    for (int i = 0; i < buffer.capacity(); i++) {
        buffer.put((byte) i);
    }

    // 创建一个只读缓冲区
    ByteBuffer readOnlyBuf = buffer.asReadOnlyBuffer();
    for (int i = 0; i < buffer.capacity(); i++) {
        byte b = buffer.get(i);
        b *= 10;
        buffer.put(i, b);
    }

    readOnlyBuf.position(0);
    readOnlyBuf.limit(readOnlyBuf.capacity());

    while (readOnlyBuf.remaining() > 0) {
        System.out.println(readOnlyBuf.get());
    }
}

3、直接缓冲区

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

// 直接缓冲区,文件拷贝
@Test
public void b03() throws IOException {
    String filePath = "/xx/01.txt";
    FileInputStream inputStream = new FileInputStream(filePath);
    FileChannel fileInChannel = inputStream.getChannel();

    String outPath = "/xx/02.txt";
    FileOutputStream outputStream = new FileOutputStream(outPath);
    FileChannel fileOutChannel1 = outputStream.getChannel();

    //  使用 allocateDirect , 而不是 allocate
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

    while (true) {
        buffer.clear();
        int r = fileInChannel.read(buffer);
        if (r == -1) {
            break;
        }
        buffer.flip();
        fileOutChannel1.write(buffer);
    }
    fileInChannel.close();
    fileOutChannel1.close();
}

4、内存映射文件 I/O

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

// 内存映射文件 I/O 
@Test
public void b04() throws IOException {
    String filePath = "/xxx/01.txt";
    RandomAccessFile randomAccessFile = new RandomAccessFile(filePath, "rw");
    FileChannel fileChannel = randomAccessFile.getChannel();
    MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
    mappedByteBuffer.put(0, (byte) 97);
    mappedByteBuffer.put(1023, (byte) 122);
    fileChannel.close();
}

到此这篇关于Java NIO 中Buffer 缓冲区解析的文章就介绍到这了,更多相关Java NIO 中Buffer 缓冲区内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java8中NIO缓冲区(Buffer)的数据存储详解

    java8新特性NIO缓冲区(Buffer)的数据存储. ByteBuffer,CharBuffer,ShortBuffer,IntBuffer,LongBuffer,FloatBuffer, DoubleBuffer. 1.缓冲区在java nio中负责数据的存储.缓冲区就是数组.用于存储不同数据类型的数据.根据数据类型不同(boolean除外),提供了相应类型的缓冲区. ByteBuffer,CharBuffer,ShortBuffer,IntBuffer,LongBuffer,FloatB

  • Java Buffer缓冲区(NIO)

    目录 Java NIO(Buffer) 1.1 Buffer 简介 1.2 Buffer 的基本用法 1.使用 Buffer 读写数据,一般遵循以下四个步骤: 2.使用 ByteBuffer的例子 3.使用 IntBuffer 的例子 1.3 Buffer 的 capacity.position 和 limit (1)capacity (2)position (3)limit 1.4 Buffer 的类型 1.5 Buffer 分配和写数据 1.Buffer 分配 2.向 Buffer 中写数据

  • 详细了解JAVA NIO之Buffer(缓冲区)

    当我们需要与 NIO Channel 进行交互时, 我们就需要使用到 NIO Buffer, 即数据从 Buffer读取到 Channel 中, 并且从 Channel 中写入到 Buffer 中.缓冲区本质上是一块可以写入数据,然后可以从中读取数据的内存.这块内存被包装成NIO Buffer对象,并提供了一组方法,用来方便的访问该块内存. 缓冲区基础 Buffer 类型有: 缓冲区是包在一个对象内的基础数据的数组,Buffer类相比一般简单数组而言其优点是将数据的内容和相关信息放在一个对象里面

  • Java NIO 中Buffer 缓冲区解析

    目录 一.Buffer 简介 二.Buffer 的基本方法 1.使用 Buffer 读写数据 2.使用 Buffer 的例子 三.Buffer 的 capactity.posittion 和limit 四.Buffer 的类型 五.Buffer 分配和写数据 1. Buffer 分配 2.向 buffer 中写数据 3.flip() 方法 六.从 Buffer 中读取数据 七.Buffer 几个方法 1.rewind() 方法 2.clear() 与 compact() 方法 3.mark()

  • Java NIO 中 Selector 解析

    目录 一.Selector 简介 1.Selector 和 Channel 关系 2.可选择通道(SelectableChannel) 3.Channel 注册到 Selector 4.选择键(SelectionKey) 二.Selector 的使用方法 1.Selector 的创建 2.注册 Channel 到 Selector 3.轮训查询就绪操作 4.停止选择的方法 三.示例代码 1.服务端代码 2.客户端代码 3.NIO 编程步骤总结 一.Selector 简介 1.Selector 和

  • 使用java NIO及高速缓冲区写入文件过程解析

    这篇文章主要介绍了使用java NIO及高速缓冲区写入文件过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 代码如下 byte[] bytes = Files.readAllBytes(Paths.get("E:\\pdf\\aaa\\html\\text.txt").normalize()); String text = IOUtils.toString(bytes); String xml = text.substring(

  • Java多态中动态绑定原理解析

    这篇文章主要介绍了Java多态中动态绑定原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 多态是面向对象程序设计非常重要的特性,它让程序拥有 更好的可读性和可扩展性. 发生在继承关系中. 需要子类重写父类的方法. 父类类型的引用指向子类类型的对象. 自始至终,多态都是对于方法而言,对于类中的成员变量,没有多态的说法. 一个基类的引用变量接收不同子类的对象将会调用子类对应的方法,这其实就是动态绑定的过程.在理解动态绑定之前,先补充一些概念.

  • 详解java nio中的select和channel

    什么是NIO? 线程在处理数据时,如果线程还处于将数据从channel读到buffer的这段时间内,线程可以去做别的事情,等数据都读到buffer了,线程再回来处理读到的数据 channel是什么? 类比流的概念.与流的区别在于 1.channel是可读可写的,但是一个流要么写要么读 2.chanel可以异步的读和写 3.数据总是从channel中读到buffer,或者从buffer中写到channel 流的读取或写一般是一次性的操作,数据在读取过程中不会有缓存,这也就意味着没有办法自己随便移动

  • Java NIO Buffer实现原理详解

    目录 1.Buffer的继承体系 2.Buffer的操作API使用案例 3.Buffer的基本原理 4.allocate方法初始化一个指定容量大小的缓冲区 5.slice方法缓冲区分片 6.只读缓冲区 7.直接缓冲区 8.内存映射 1.Buffer的继承体系 如上图所示,对于Java中的所有基本类型,都会有一个具体的Buffer类型与之对应,一般我们最经常使用的是ByteBuffer. 2.Buffer的操作API使用案例 举一个IntBuffer的使用案例: /** * @author csp

  • Java NIO异步文件通道原理及用法解析

    在Java 7,AsynchronousFileChannel 被添加到了Java NIO中.使用AsynchronousFileChannel可以实现异步地读取和写入文件数据. 创建一个AsynchronousFileChannel 我们可以使用AsynchronousFileChannel提供的静态方法 open() 创建它.示例代码如下: Path path = Paths.get("data/test.xml"); AsynchronousFileChannel fileCha

  • java NIO 详解

    Java NIO提供了与标准IO不同的IO工作方式: Channels and Buffers(通道和缓冲区):标准的IO基于字节流和字符流进行操作的,而NIO是基于通道(Channel)和缓冲区(Buffer)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中. Asynchronous IO(异步IO):Java NIO可以让你异步的使用IO,例如:当线程从通道读取数据到缓冲区时,线程还是可以进行其他事情.当数据被写入到缓冲区时,线程可以继续处理它.从缓冲区写入通道也类似. S

随机推荐