java.nio.ByteBuffer字节缓冲区源码解析

1.Buffer的解析

http://blog.csdn.net/ya_1249463314/article/details/79205409

2.所属包

package java.nio;

3.继承与实现关系

public abstract class ByteBuffer
    extends Buffer
    implements Comparable<ByteBuffer>

4.常用变量

//堆缓冲数组
final byte[] hb;                 //字节数组偏移量
    final int offset;
	//堆缓冲是否可读
    boolean isReadOnly;

5.构造器

 /**
	 * 创建一个带有临时备忘标记变量、读写的开始位置pos、
	 * 读写的最大容量lim、缓冲区的最大容量cap、字节数组、偏移量的构造器
	 */
    ByteBuffer(int mark, int pos, int lim, int cap, byte[] hb, int offset) {
        super(mark, pos, lim, cap);
        this.hb = hb;
        this.offset = offset;
    }

    /**
	 * 创建一个带有临时备忘标记变量mark、读写的开始位置pos、
	 * 读写的最大容量lim、缓冲区的最大容量cap，字节数组为null，数组偏移量为0的缓冲区
	 */
    ByteBuffer(int mark, int pos, int lim, int cap) { 
        this(mark, pos, lim, cap, null, 0);
    }

6.常用的方法

/**
     * 分配一个新的指定容量的缓冲区
     */
    public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
    }

    /**
     * 分配一个新的指定容量字节缓冲区
     */
    public static ByteBuffer allocate(int capacity) {
		//如果容量小于0，那么抛出非法参数异常
        if (capacity < 0)
            throw new IllegalArgumentException();
		//返回一个堆字节缓冲区
        return new HeapByteBuffer(capacity, capacity);
    }

    /**
     * 封装字节数组到缓冲区中  
	 * 输入参数为字节数组，数组的偏移量，长度
     */
    public static ByteBuffer wrap(byte[] array,int offset, int length) {
        try {
            return new HeapByteBuffer(array, offset, length);
        } catch (IllegalArgumentException x) {
            throw new IndexOutOfBoundsException();
        }
    }

    /**
     * 封装字节数组到缓冲区中
     */
    public static ByteBuffer wrap(byte[] array) {
        return wrap(array, 0, array.length);
    }

    /**
     * 创建新的字节缓冲区，其内容是此缓冲区内容的共享子序列。
     */
    public abstract ByteBuffer slice();

    /**
     * 创建共享此缓冲区内容的新的字节缓冲区。
     */
    public abstract ByteBuffer duplicate();

    /**
     * 创建共享此缓冲区内容的新的只读字节缓冲区。
     */
    public abstract ByteBuffer asReadOnlyBuffer();

    /**
     * 读取缓冲区中的字节
     */
    public abstract byte get();

    /**
     * 将给定的字节写入此缓冲区的当前位置，然后该位置递增。
     */
    public abstract ByteBuffer put(byte b);

    /**
     * 从指定的索引处获取字节
     */
    public abstract byte get(int index);

    /**
     * 将给定字节写入此缓冲区的给定索引处。 
	 * index为指定的索引，b为给定的字节
     */
    public abstract ByteBuffer put(int index, byte b);

    /**
     * 将缓冲区中的数据获取复制到输入的字节数组中，赋值的开始偏移量为offset，赋值的长度为length
     */
    public ByteBuffer get(byte[] dst, int offset, int length) {
		//检查下标是否超出
        checkBounds(offset, length, dst.length);
		//缓冲区Buffer的剩余元素的数量小于获取的长度，抛出缓冲区溢出错误。
        if (length > remaining())
            throw new BufferUnderflowException();
		//数组的偏移量加上长度为数组尾元素的下标
        int end = offset + length;
		//从数组的偏移量开始到数组的尾下标处，开始遍历获取元素
        for (int i = offset; i < end; i++)
            dst[i] = get();
		//返回当前的字节缓冲区
        return this;
    }

    /**
     * 将缓冲区中的数据获取复制到输入的字节数组中
     */
    public ByteBuffer get(byte[] dst) {
        return get(dst, 0, dst.length);
    }

    /**
     * 将输入的指定缓冲区中的元素转移到另一个缓冲区中
     */
    public ByteBuffer put(ByteBuffer src) {
		//如果指定输入的缓冲区就是当前的缓冲区，那么抛出非法参数异常。
        if (src == this)
            throw new IllegalArgumentException();
		//获取输入的缓冲区中存放元素的数量
        int n = src.remaining();
        if (n > remaining())
            throw new BufferOverflowException();
		//循环遍历输入缓冲区中的元素将其放到当前的缓冲区中
        for (int i = 0; i < n; i++)
            put(src.get());
		//返回当前的缓冲区
        return this;
    }

    /**
     * 将指定的字节数组中的一段数据放到字节缓冲区中
     */
    public ByteBuffer put(byte[] src, int offset, int length) {
		//检查下标是否超出
        checkBounds(offset, length, src.length);
		//缓冲区Buffer的剩余元素的数量小于获取的长度，抛出缓冲区溢出错误。
        if (length > remaining())
            throw new BufferOverflowException();
		//输入的字节数组的尾元素的下标
        int end = offset + length;
		//循环遍历缓冲区中的元素放入到当前的缓冲区中
        for (int i = offset; i < end; i++)
            this.put(src[i]);
		//返回当前的字节缓冲区
        return this;
    }

    /**
     * 将指定的字节数组中的数据放到字节缓冲区中
     */
    public final ByteBuffer put(byte[] src) {
        return put(src, 0, src.length);
    }

    /**
     * 缓冲区是否有一个可访问的字节数组支持
     */
    public final boolean hasArray() {
        return (hb != null) && !isReadOnly;
    }

    /**
     * 获取字节数组
     */
    public final byte[] array() {
        if (hb == null)
            throw new UnsupportedOperationException();
        if (isReadOnly)
            throw new ReadOnlyBufferException();
        return hb;
    }

    /**
     * 获取数组的偏移量
     */
    public final int arrayOffset() {
        if (hb == null)
            throw new UnsupportedOperationException();
        if (isReadOnly)
            throw new ReadOnlyBufferException();
        return offset;
    }

    public abstract ByteBuffer compact();

    /**
     * 判断缓冲区是否是直接缓冲区
     */
    public abstract boolean isDirect();

    /**
     * 返回缓冲区的hash值
     */
    public int hashCode() {
        int h = 1;
        int p = position();
        for (int i = limit() - 1; i >= p; i--)
            h = 31 * h + (int)get(i);
        return h;
    }

	//比较输入的缓冲区中的字节和当前的缓冲区中的字节是否都相同，如果都相同就返回0
    public int compareTo(ByteBuffer that) {
        int n = this.position() + Math.min(this.remaining(), that.remaining());
        for (int i = this.position(), j = that.position(); i < n; i++, j++) {
            int cmp = compare(this.get(i), that.get(j));
            if (cmp != 0)
                return cmp;
        }
        return this.remaining() - that.remaining();
    }

	//比较两个字节
    private static int compare(byte x, byte y) {
        return Byte.compare(x, y);
    }
   
    boolean bigEndian                                   // package-private
        = true;
    boolean nativeByteOrder                             // package-private
        = (Bits.byteOrder() == ByteOrder.BIG_ENDIAN);

	//获取此缓冲区的字节顺序
    public final ByteOrder order() {
        return bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
    }

	//修改此缓冲区的字节顺序
    public final ByteBuffer order(ByteOrder bo) {
        bigEndian = (bo == ByteOrder.BIG_ENDIAN);
        nativeByteOrder =
            (bigEndian == (Bits.byteOrder() == ByteOrder.BIG_ENDIAN));
        return this;
    }