2-2 Byte数组与缓冲区基础

第一节 byte数组基础

一、Byte数据类型

Bit 意为"位"或"比特"，是计算机运算的基础单位；Byte 意为"字节"，是计算机文件大小的基本计算单位。1 bit 就是1位二进制数，比如 1 或者 0；1 Byte 就是 1 个字节，1 个字节是由8个二进制位组成的。比如1111111，00000000等。

Byte是java中的八大基本数据类型之一，byte是Byte的拆箱数据类型。

数据转换

我们在开发过程中，编辑器使用的数值默认是10进制的，毕竟十进制是普及到街巷市井的一个数制，即便是我们懂得二进制的人，十进制的可读性也比较习惯。而对计算机则不然，因为它的底层存储机制为二进制，但是二进制的读取对我们人类而言则不是那么方便，8位二进制正好可以使用2个十六进制数字表示，相比二进制，表述也更加简便。

举个例子，比如二进制表示表示一个字节的值为10110110，使用十六进制则可以简单表示为B6。

数组截取

本案例中，我们经常会遇到字节数组的截取。

System.arraycopy(src, srcPos, dest, destPos, length)的使用：

    /* @param      src      the source array.
     * @param      srcPos   starting position in the source array.
     * @param      dest     the destination array.
     * @param      destPos  starting position in the destination data.
     * @param      length   the number of array elements to be copied.
     * @exception  IndexOutOfBoundsException  if copying would cause
     *               access of data outside array bounds.
     * @exception  ArrayStoreException  if an element in the <code>src</code>
     *               array could not be stored into the <code>dest</code> array
     *               because of a type mismatch.
     * @exception  NullPointerException if either <code>src</code> or
     *               <code>dest</code> is <code>null</code>.
     */
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

参数解释：

• Object src : 原数组
• int srcPos : 从原数组中截取数据的起始位置
• Object dest : 目标数组
• int destPos : 目标数组的开始起始位置
• int length : 从原数组中截取数据时要copy的数组的长度

比如 ：我们有一个数组数据

    byte[]  srcBytes = new byte[]{2,4,0,0,0,0,0,10,15,50};  // 源数组
    byte[] destBytes = new byte[5]; // 目标数组

    System.arrayCopy(srcBytes,0,destBytes ,0,5);

则最终destBytes中的元素为：{2,4,0,0,0}。

数组合并

关于数组合并，我们还会经常用到，commons-lang3.jar包中的ArrayUtils类的addAll()，其功能是添加一个字节数组或者添加一个字节到原先的字节数组中。

public static byte[] addAll(byte[] array1, byte... array2) {
        if (array1 == null) {
            return clone(array2);
        } else if (array2 == null) {
            return clone(array1);
        } else {
            byte[] joinedArray = new byte[array1.length + array2.length];
            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
            return joinedArray;
        }
    }

第二节 缓冲区基础

在开始之前，我觉得有必要充分理解一下缓冲区的作用及使用方法。

一、缓冲区基础

在NIO技术的缓冲区中，存在4个核心技术点，分别是：
❑capacity（容量）
❑limit（限制）
❑position（位置）
❑mark（标记）
这4个技术点之间值的大小关系如下：0≤mark≤position≤limit≤capacity。

由于ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer和ShortBuffer是抽象类，wrap()就相当于创建这些缓冲区的工厂方法。最终对应的类型分别为java.io.HeapByteBuffer、java.io.HeapCharBuffer、java.io.HeapDoubleBuffe等。

limit

限制（limit）代表第一个不应该读取或写入元素的index，缓冲区的limit不能为负，并且limit不能大于其capacity。如果position大于新的limit，则将position设置为新的limit。如果mark已定义且大于新的limit，则丢弃该mark。

public class BufferTest {
    @Test
    public void bufferLimitTest(){
        char[] charArray = new char[]{'a','b','c','d','e'};
        CharBuffer buffer = CharBuffer.wrap(charArray);
        System.out.println("A capacity()=" + buffer.capacity() + "，limit="+buffer.limit());

        buffer.limit(3);
        System.out.println("B capacity()=" + buffer.capacity() + "，limit="+buffer.limit());

        buffer.put(0,'o');
        buffer.put(1,'p');
        buffer.put(2,'q');
        buffer.put(3,'r');//index == 3,第一个不可读不可写的索引
        buffer.put(4,'s');
        buffer.put(5,'t');
        buffer.put(6,'u');
    }
}

position（位置）

什么是位置呢？它代表“下一个”要读取或写入元素的index（索引），缓冲区的position（位置）不能为负，并且position不能大于其limit。如果mark已定义且大于新的position，则丢弃该mark。

    @Test
    public void bufferLimitTest(){
        char[] charArray = new char[]{'a','b','c','d','e'};
        CharBuffer buffer = CharBuffer.wrap(charArray);
        System.out.println("A capacity()=" + buffer.capacity() + "，limit="+buffer.limit()+ "，position="+buffer.position());

        buffer.limit(3);
        System.out.println("B capacity()=" + buffer.capacity() + "，limit="+buffer.limit() + "，position="+buffer.position());

        buffer.put(0,'o');
        buffer.put(1,'p');
        buffer.put(2,'q');
        buffer.put(3,'r');//index == 3,第一个不可读不可写的索引
        buffer.put(4,'s');
        buffer.put(5,'t');
        buffer.put(6,'u');
    }

运行结果如下：
A capacity()=5，limit=5，position=0
B capacity()=5，limit=5，position=2
a
b
Z
d
e

mark（标记）

标记有什么作用呢？缓冲区的标记是一个索引，在调用reset()方法时，会将缓冲区的position位置重置为该索引。标记（mark）并不是必需的。定义mark时，不能将其定义为负数，并且不能让它大于position。

• 如果定义了mark，则在将position或limit调整为小于该mark的值时，该mark被丢弃，丢弃后mark的值是-1。
• 如果未定义mark，那么调用reset()方法将导致抛出InvalidMarkException异常。

简而言之，buffer的reset()方法，可以根据mark()的位置，把位置重置为mark()调用时的位置。

其他的一些关系：

• 如果position大于新的limit，则position的值就是新limit的值。

二、非直接缓冲区和直接缓冲区

非直接缓冲区

通过ByteBuffer向硬盘存取数据时是需要将数据暂存在JVM的中间缓冲区，如果有频繁操作数据的情况发生，则在每次操作时都会将数据暂存在JVM的中间缓冲区，再交给ByteBuffer处理，这样做就大大降低软件对数据的吞吐量，提高内存占有率，造成软件运行效率降低，这就是非直接缓冲区保存数据的过程，所以非直接缓冲区的这个弊端就由直接缓冲区解决了。

直接缓冲区