Java NIO（Buffer）

  • 3.1 Buffer简介
  • 3.2 Buffer的基本使用
  • （1） 使用Buffer读写数据，一般遵循以下四个步骤
  • （2）使用buffer的例子
  • 3.3 Buffer的capacity、position和limit
  • （1）capacity
  • （2）position
  • （3）limit
  • 3.4 Buffer的类型
  • 3.5 Buffer分配和写数据
  • （1）Buffer分配
  • （2）向Buffer中写数据
  • （3）flip方法
  • 3.6 从Buffer中读取数据
  • 3.7 Buffer的几个方法
  • （1）rewind()方法
  • （2）clear()与compact()方法
  • （3）mark()与reset()方法
  • 3.8 缓冲区操作
  • （1）缓冲区分片
  • （2）只读缓冲区
  • （3）直接缓冲区
  • （4）内存映射文件I/O


3.1 Buffer简介

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

java将buffer转成图片数据流_写数据


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

在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示：

java将buffer转成图片数据流_java将buffer转成图片数据流_02

3.2 Buffer的基本使用

（1） 使用Buffer读写数据，一般遵循以下四个步骤

（1）写入数据到Buffer
（2）调用flip()方法进行模式转换
（3）从Buffer中读取数据
（4）调用clear()方法或者compact()方法

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

（2）使用buffer的例子

使用FileChannel去读文件

@Test
    public void buffer01() throws Exception {
        //FileChannel
        RandomAccessFile aFile =
                new RandomAccessFile("/Users/xxx/01.txt", "rw");
        FileChannel channel = aFile.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();
            bytesRead = channel.read(buffer);
        }
    }

打印：

h
e
l
l
o

3.3 Buffer的capacity、position和limit

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

  • Capacity
  • Position
  • limit

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

这里有一个关于capacity、position和limit在读写模式中的说明

java将buffer转成图片数据流_数据_03

（1）capacity

座位一个内存块，Buffer有一个固定的大小值，也叫『capacity』。你只能往里写capacity个byte、long、char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清除数据）才能继续往里写数据

（2）position

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

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

（3）limit

写数据时，limit表示可对Buffer最多写入多少个数据。写模式下，limit等于Buffer的capacity

读数据时，limit表示Buffer里有多少个可读数据（not null）数据，因此能读到之前写入的所有数据（limit被设置成已写数据的数据，这个值在写模式下就是position）

3.4 Buffer的类型

Java NIO有以下Buffer类型

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

3.5 Buffer分配和写数据

（1）Buffer分配

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

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

ByteBuffer buf = ByteBuffer.allocate(48);

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

CharBuffer buf = CharBuffer.allocate(48);

（2）向Buffer中写数据

写数据到Buffer有两种方式：

  1. 从Channel写到Buffer
  2. 通过Buffer的put()方法写到Buffer里

方式一：从Channel写到Buffer的例子

int bytesRead = inChannel.read(buf);

方式二：通过put方法写Buffer的例子

buf.put(127);

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

（3）flip方法

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

3.6 从Buffer中读取数据

从Buffer中读取数据有两种方式：

  1. 从Buffer读取数据到Channel
  2. 使用get()方法从Buffer中读取数据

方式一：从Buffer读取数据到channel

int bytesWritten = inChannel.write(buf);

方式二：使用get()方法从Buffer中读取数据

byte aByte = buf.get();

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

3.7 Buffer的几个方法

（1）rewind()方法

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

（2）clear()与compact()方法

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

如果调用的是clear()方法，position将设回0，limit被设置成capacity的值。换句话说，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();
//再回滚
buffer.reset();

3.8 缓冲区操作

（1）缓冲区分片

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

用例：

package com.study.buffer;

import org.junit.Test;

import java.nio.ByteBuffer;

public class BufferDemo2 {

    @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());
        }
    }
}

打印：

0
1
2
30
40
50
60
7
8
9

（2）只读缓冲区

只读缓冲区非常简单，可以读取它们，但是不能向它们写入数据。可以通过调用缓冲区的asReadOnlyBuffer()方法，将任何常规缓冲区转换为只读缓冲区，这个方法返回一个与原缓冲区完全相同的缓冲区，并与原缓冲区共享数据，只不过它是只读的。

如果原缓冲区的内容发生了变化，只读缓冲区的内容也随之变化。

示例：

@Test
public void b02(){
    ByteBuffer buffer = ByteBuffer.allocate(10);

    for(int i = 0; i < buffer.capacity(); i ++){
        buffer.put((byte) i);
    }

    //创建只读缓冲区
    ByteBuffer readonly = buffer.asReadOnlyBuffer();

    for(int i = 0; i < buffer.capacity(); i ++){
        byte b = buffer.get(i);
        b *= 10;
        buffer.put(i, b);
    }

    readonly.position(0);
    readonly.limit(buffer.capacity());

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

打印：

0
10
20
30
40
50
60
70
80
90

（3）直接缓冲区

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

@Test
public void b03() throws Exception {
    String infile = "/Users/xxx/01.txt";
    FileInputStream fin = new FileInputStream(infile);
    FileChannel finChannel = fin.getChannel();

    String outfile = "/Users/xxx/02.txt";
    FileOutputStream fout = new FileOutputStream(outfile);
    FileChannel foutChannel = fout.getChannel();

    //创建直接缓冲区
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
    while(true){
        buffer.clear();

        int r = finChannel.read(buffer);
        if(r == -1){
            break;
        }
        buffer.flip();
        foutChannel.write(buffer);
    }
}

（4）内存映射文件I/O

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

static private final int start = 0;
static private final int size = 1024;

//内存映射文件io
@Test
public void b04() throws Exception {
    RandomAccessFile raf = new RandomAccessFile("/Users/xxx/01.txt", "rw");
    FileChannel fc = raf.getChannel();
    MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, start, size);

    mbb.put(0, (byte) 97);
    mbb.put(1023, (byte) 122);
    raf.close();
}