【Java】Java NIO 之 Buffer 缓冲区（二）

一、Buffer(缓冲区)介绍

1.1、Buffer(缓冲区)介绍

　　Java NIO Buffers用于和NIO Channel交互。 我们从Channel中读取数据到buffers里，从Buffer把数据写入到Channels.

　　Buffer本质上就是一块内存区，可以用来写入数据，并在稍后读取出来。这块内存被NIO Buffer包裹起来，对外提供一系列的读写方便开发的接口。

　　在Java NIO中使用的核心缓冲区如下（覆盖了通过I/O发送的基本数据类型：byte, char、short, int, long, float, double ，long）

• ByteBuffer

• CharBuffer

• ShortBuffer

• IntBuffer

• FloatBuffer

• DoubleBuffer

• LongBuffer

 　

1.2、Buffer的基本用法

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

1. 写入数据到Buffer
2. 调用flip()方法
3. 从Buffer中读取数据
4. 调用clear()方法或者compact()方法

　　当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。

　　一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

1.3、Buffer的容量，位置，上限（Buffer Capacity, Position and Limit）

　　Buffer缓冲区实质上就是一块内存，用于写入数据，也供后续再次读取数据。这块内存被NIO Buffer管理，并提供一系列的方法用于更简单的操作这块内存。

　　一个Buffer有三个属性是必须掌握的，分别是：

• capacity（容量）

• position（位置）

• limit（限制）

　　position和limit的具体含义取决于当前buffer的模式。capacity在两种模式下都表示容量。

　　这里有一个关于capacity，position和limit在读写模式中的说明，详细的解释在插图后面。

　　

　　capacity（容量）

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

　　position（位置）

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

　　position最大可为capacity-1.

　　当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0. 当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。

　　limit（限制）

　　在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下，limit等于Buffer的capacity。

　　当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）

二、Buffer的常见方法

方法	介绍
abstract Object array()	返回支持此缓冲区的数组 （可选操作）
abstract int arrayOffset()	返回该缓冲区的缓冲区的第一个元素的在数组中的偏移量 （可选操作）
int capacity()	返回此缓冲区的容量
Buffer clear()	清除此缓存区。将position = 0;limit = capacity;mark = -1;
Buffer flip()	flip()方法可以吧Buffer从写模式切换到读模式。调用flip方法会把position归零，并设置limit为之前的position的值。 也就是说，现在position代表的是读取位置，limit标示的是已写入的数据位置。
abstract boolean hasArray()	告诉这个缓冲区是否由可访问的数组支持
boolean hasRemaining()	return position < limit，返回是否还有未读内容
abstract boolean isDirect()	判断个缓冲区是否为 direct
abstract boolean isReadOnly()	判断告知这个缓冲区是否是只读的
int limit()	返回此缓冲区的限制
Buffer position(int newPosition)	设置这个缓冲区的位置
int remaining()	return limit - position; 返回limit和position之间相对位置差
Buffer rewind()	把position设为0，mark设为-1，不改变limit的值
Buffer mark()	将此缓冲区的标记设置在其位置

三、Buffer的使用方式/方法介绍

3.1、分配缓冲区（Allocating a Buffer）

　　为了获得缓冲区对象，我们必须首先分配一个缓冲区。在每个Buffer类中，allocate()方法用于分配缓冲区。

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

ByteBuffer buf = ByteBuffer.allocate(48);

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

CharBuffer buf = CharBuffer.allocate(1024);

3.2、写入数据到缓冲区（Writing Data to a Buffer）

　　写数据到Buffer有两种方法：

• 从Channel中写数据到Buffer

• 手动写数据到Buffer，调用put方法

　　从Channel写到Buffer的例子

int bytesRead = inChannel.read(buf); //read into buffer.

　　通过put方法写Buffer的例子：

buf.put(127);

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

3.3、翻转（flip()）

　　flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。

　　换句话说，position现在用于标记读的位置，limit表示之前写进了多少个byte、char等 —— 现在能读取多少个byte、char等。

3.4、从Buffer读取数据（Reading Data from a Buffer）

　　从Buffer读数据也有两种方式。

• 从buffer读数据到channel

• 从buffer直接读取数据，调用get方法

　　从Buffer读取数据到Channel的例子：

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

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

byte aByte = buf.get();

　　get方法有很多版本，允许你以不同的方式从Buffer中读取数据。例如，从指定position读取，或者从Buffer中读取数据到字节数组。更多Buffer实现的细节参考JavaDoc。

3.5、rewind()方法

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

3.6、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.7、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.

3.8、equals()与compareTo()方法

　　可以使用equals()和compareTo()方法两个Buffer。

　　equals()

　　当满足下列条件时，表示两个Buffer相等：

1. 有相同的类型（byte、char、int等）。
2. Buffer中剩余的byte、char等的个数相等。
3. Buffer中所有剩余的byte、char等都相同。

　　如你所见，equals只是比较Buffer的一部分，不是每一个在它里面的元素都比较。实际上，它只比较Buffer中的剩余元素。

　　compareTo()方法

　　compareTo()方法比较两个Buffer的剩余元素(byte、char等)， 如果满足下列条件，则认为一个Buffer“小于”另一个Buffer：

1. 第一个不相等的元素小于另一个Buffer中对应的元素 。
2. 所有元素都相等，但第一个Buffer比另一个先耗尽(第一个Buffer的元素个数比另一个少)。

四、Buffer常用方法测试

　　这里以ByteBuffer为例子说明抽象类Buffer的实现类的一些常见方法的使用：

/**
 * 1、缓冲区（Buffer）：
 *      在Java NIO 中负责数据的存取，缓冲区九是数组，用于存储不同数据类型的数据
 * 根据数据类型不同（boolean除外），提供了相应类型的缓冲区
 * ByteBuffer
 * CharBuffer
 * ShortBuffer
 * IntBuffer
 * LongBuffer
 * FloatBuffer
 * DoubleBuffer
 *
 * 2、缓冲区存取数据的两个核心方法：
 * put() ：存入数据到缓冲区中
 * get()：获取缓冲区中的数据
 *
 * 3、缓冲区中的四个核心属性：
 * capacity：容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变
 * limit：界限，表示缓冲区中可以操作数据的大小，代表了当前缓冲区中一共有多少数据。。（limit 后数据不能进行读写）
 * position：位置，表示缓冲区中正在操作数据的位置，Position会自动由相应的 get( )和 put( )函数更新
 * mark：标记，一个备忘位置。用于记录当前position位置，可以通过过reset() 恢复到 mark 的位置。
 *
 * 规律
 * mark <= position <= limit <= capacity
 *
 * 4、直接缓冲区与非直接缓冲区
 * 非直接缓冲区：通过allocate() 方法分配，将缓冲区建立在 JVM 的内存中
 * 直接缓冲区：通过allocateDirect() 方法分配，将缓冲区建立在物理内存中，可以提高效率
 *
 *
 */
public class BufferTest {

    /**
     * 测试常用方法
     */
    @Test
    public void test1(){
        // 1、分配一个指定大小的缓存区
        ByteBuffer buf = ByteBuffer.allocate(5);

        System.out.println("----------allocate()---------");
        System.out.println("position == " + buf.position());
        System.out.println("limit == " + buf.limit());
        System.out.println("capacity == " + buf.capacity());


        // 2、利用put() 存入数据到缓冲区区
        buf.put("abcde".getBytes());

        System.out.println("----------put()---------");
        System.out.println("position == " + buf.position());
        System.out.println("limit == " + buf.limit());
        System.out.println("capacity == " + buf.capacity());

        // 3、利用flip() 切换读取数据模式
        buf.flip();

        System.out.println("----------flip()---------");
        System.out.println("position == " + buf.position());
        System.out.println("limit == " + buf.limit());
        System.out.println("capacity == " + buf.capacity());

        // 4、利用get() 读取缓冲区中的数据
        byte[] dst = new byte[buf.limit()];
        buf.get(dst);

        System.out.println("----------get()---------");
        System.out.println("position == " + buf.position());
        System.out.println("limit == " + buf.limit());
        System.out.println("capacity == " + buf.capacity());

        System.out.println(new String(dst, 0, dst.length));

        // 5、利用rewind() 回到读模式（可重复读数据）
        buf.rewind();

        System.out.println("----------rewind()---------");
        System.out.println("position == " + buf.position());
        System.out.println("limit == " + buf.limit());
        System.out.println("capacity == " + buf.capacity());

        // 6、利用clear() 清空缓冲区，当是缓冲区的数据还在，可看源码
        buf.clear();

        System.out.println("----------clear()---------");
        System.out.println("position == " + buf.position());
        System.out.println("limit == " + buf.limit());
        System.out.println("capacity == " + buf.capacity());

        // 测试数据并未被清空
        System.out.println((char)buf.get());

    }

    /**
     * 测试mark 方法
     */
    @Test
    public void test2(){
        ByteBuffer buf = ByteBuffer.allocate(1024);
        buf.put("abcdefg".getBytes());
        buf.flip();

        byte[] dst = new byte[buf.limit()];
        buf.get(dst, 0, 2);
        System.out.println(new String(dst, 0, 2));
        System.out.println("position === " + buf.position());

        buf.mark();

        buf.get(dst, 2, 2);
        System.out.println(new String(dst, 2, 2));
        System.out.println("position === " + buf.position());

        // 重置到mark的位置
        buf.reset();
        System.out.println("position === " + buf.position());


        // 判断缓冲区中是否还有剩余数据
        if(buf.hasRemaining()) {
            // 获取缓冲区中，可以操作的数据数量
            System.out.println("remaining === " + buf.remaining());
        }
    }

    /**
     * 直接缓冲区与非直接缓冲区
     */
    @Test
    public void test3(){
        ByteBuffer buf = ByteBuffer.allocateDirect(1024);

        System.out.println(buf.isDirect());
    }
}

 　　编码解码示例：

    // 5】字符集
    @Test
    public void test5(){
        SortedMap<String, Charset> map = Charset.availableCharsets();

        Set<Map.Entry<String, Charset>> set = map.entrySet();

        for (Map.Entry<String, Charset> entry: set) {
            System.out.println(entry.getKey() + " === " + entry.getValue());
        }
    }

    // 6】测试字符集
    @Test
    public void test6(){

        try {

            Charset cs1 = Charset.forName("UTF-8");
            // 获取编码器
            CharsetEncoder ce = cs1.newEncoder();

            // 获取解码器
            CharsetDecoder cd = cs1.newDecoder();

            CharBuffer cBuf = CharBuffer.allocate(1024);
            cBuf.put("我是中国人");
            cBuf.flip();

            // 编码
            ByteBuffer bBuf = ce.encode(cBuf);
            for (int i = 0; i < 12 && i < bBuf.limit(); i ++ ) {
                System.out.println(bBuf.get());
            }

            // 解码
            bBuf.flip();
            CharBuffer cBuf2 = cd.decode(bBuf);
            System.out.println(cBuf2.toString());

            System.out.println("-----------------");

            // 编码解码不一致
            bBuf.flip();
            Charset cs2 = Charset.forName("GBK");
            CharBuffer cBuf3 = cs2.decode(bBuf);
            System.out.println(cBuf3.toString());
        } catch (CharacterCodingException e) {
            e.printStackTrace();
        }

    }