Module  java.base
软件包  java.nio

Class ByteBuffer

  • All Implemented Interfaces:
    Comparable<ByteBuffer>
    已知直接子类:
    MappedByteBuffer


    public abstract class ByteBuffer
    extends Buffer
    implements Comparable<ByteBuffer>
    一个字节缓冲区。

    这个类在字节缓冲区中定义了六类操作:

    • 绝对和相对getput读写单字节的方法;

    • 相对bulk get方法将连续的字节序列从该缓冲区传输到数组中;

    • 相对bulk put方法,将字节数组或其他字节缓冲区的连续字节序列传输到此缓冲区中;

    • 绝对和相对的getput方法,读取和写入其他原始类型的值,将它们转换为特定字节顺序的字节序列;

    • 创建view buffers的方法,允许将字节缓冲区视为包含某些其他原始类型的值的缓冲区;

    • 一种方法为compacting一个字节缓冲区。

    字节缓冲区可以由allocation创建,它为缓冲区的内容分配空间,或者通过wrapping将现有字节数组分配到缓冲区中。

    直接非直接缓冲区

    字节缓冲区是直接 或非直接的 给定一个直接的字节缓冲区,Java虚拟机将尽力在其上直接执行本地I / O操作。 也就是说,它将尝试避免在每次调用其中一个底层操作系统的本机I / O操作之前(或之后)将缓冲区的内容复制到(或从)中间缓冲区。

    可以通过调用此类的allocateDirect工厂方法来创建直接字节缓冲区。 此方法返回的缓冲区通常比非直接缓冲区具有更高的分配和释放成本。 直接缓冲区的内容可能驻留在正常垃圾回收堆之外,因此它们对应用程序的内存占用的影响可能不明显。 因此,建议直接缓冲区主要用于受基础系统本机I / O操作影响的大型长寿命缓冲区。 一般来说,最好只在产生程序性能可测量的增益时才分配直接缓冲区。

    一个直接字节缓冲区也可以通过mapping一个文件的区域直接创建到内存中。 Java平台的实现可以可选地支持通过JNI从本地代码创建直接字节缓冲器。 如果这些缓冲区之一的实例指的是存储器的不可访问的区域,则访问该区域的尝试将不会改变缓冲区的内容,并且将导致在访问时或之后的某个未指定的异常时间。

    字节缓冲区是直接还是非直接可以通过调用其isDirect方法来确定。 提供了这种方法,使得可以在性能关键代码中进行显式缓冲区管理。

    访问二进制数据

    该类定义了读取和写入所有其他原始类型的值的方法,除了boolean 原始值根据缓冲区的当前字节顺序转换为(或从)字节序列,可以通过order方法检索和修改。 特定字节顺序由ByteOrder类的实例表示。 字节缓冲区的初始顺序始终为BIG_ENDIAN

    对于访问异构二进制数据,即不同类型的值序列,此类定义了每个类型的绝对和相对getput方法族。 例如,对于32位浮点值,此类定义:

     float  getFloat()
     float  getFloat(int index)
      void  putFloat(float f)
      void  putFloat(int index, float f)

    对于类型char, short, int, longdouble定义了相应的方法。 绝对getput方法的索引参数是以字节为单位,而不是读取或写入的类型。

    对于访问同构二进制数据,即相同类型的值序列,该类定义了可以创建给定字节缓冲区的视图的方法。 视图缓冲区只是另一个缓冲区,其内容由字节缓冲区支持。 对字节缓冲区内容的更改将在视图缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值是独立的。 例如, asFloatBuffer方法创建一个FloatBuffer类的实例,该实例由调用该方法的字节缓冲区支持。 相应的视图创建方法是针对类型char, short, int, longdouble

    与上述类型特定的getput方法相比,查看缓冲区有三个重要的优点:

    • 视图缓冲区不是以字节为单位,而是根据其值的类型特定大小进行索引;

    • 视图缓冲器提供相对的批量获取放置方法,该方法可以在缓冲区和数组之间传递连续序列值或者相同类型的其他缓冲区;

    • 视图缓冲区可能会更有效率,因为只有当它的后备字节缓冲区是直接的时才会是直接的。

    在创建视图时,视图缓冲区的字节顺序被固定为其字节缓冲区的字节顺序。

    调用链接

    指定此类中没有值返回值的方法返回调用它们的缓冲区。 这允许方法调用被链接。 语句序列

     bb.putInt(0xCAFEBABE);
     bb.putShort(3);
     bb.putShort(45);
    例如,可以用单个语句来替换
     bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
    从以下版本开始:
    1.4
    • 方法摘要

      所有方法  静态方法  接口方法  抽象方法  具体的方法 
      Modifier and Type 方法 描述
      ByteBuffer alignedSlice​(int unitSize)
      创建一个新的字节缓冲区,其内容是此缓冲区内容的共享和对齐子序列。
      int alignmentOffset​(int index, int unitSize)
      返回内存地址,指向给定索引处的字节,模拟给定的单位大小。
      static ByteBuffer allocate​(int capacity)
      分配一个新的字节缓冲区。
      static ByteBuffer allocateDirect​(int capacity)
      分配一个新的直接字节缓冲区。
      byte[] array​()
      返回支持此缓冲区的字节数组 (可选操作)
      int arrayOffset​()
      返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量 (可选操作)
      abstract CharBuffer asCharBuffer​()
      创建一个字节缓冲区作为char缓冲区的视图。
      abstract DoubleBuffer asDoubleBuffer​()
      将此字节缓冲区的视图创建为双缓冲区。
      abstract FloatBuffer asFloatBuffer​()
      将此字节缓冲区的视图创建为浮动缓冲区。
      abstract IntBuffer asIntBuffer​()
      将此字节缓冲区的视图创建为int缓冲区。
      abstract LongBuffer asLongBuffer​()
      将此字节缓冲区的视图创建为长缓冲区。
      abstract ByteBuffer asReadOnlyBuffer​()
      创建一个新的只读字节缓冲区,共享此缓冲区的内容。
      abstract ShortBuffer asShortBuffer​()
      将此字节缓冲区的视图创建为短缓冲区。
      ByteBuffer clear​()
      清除此缓冲区。
      abstract ByteBuffer compact​()
      压缩此缓冲区 (可选操作)
      int compareTo​(ByteBuffer that)
      将此缓冲区与另一个缓冲区进
      abstract ByteBuffer duplicate​()
      创建一个新的字节缓冲区,共享此缓冲区的内容。
      boolean equals​(Object ob)
      告诉这个缓冲区是否等于另一个对象。
      ByteBuffer flip​()
      翻转这个缓冲区。
      abstract byte get​()
      相对 获取方法。
      ByteBuffer get​(byte[] dst)
      相对批量 获取方法。
      ByteBuffer get​(byte[] dst, int offset, int length)
      相对批量 获取方法。
      abstract byte get​(int index)
      绝对 获取方法。
      abstract char getChar​()
      读取char值的相对 get方法。
      abstract char getChar​(int index)
      绝对 获取方法来读取一个char值。
      abstract double getDouble​()
      读取双重值的相对 get方法。
      abstract double getDouble​(int index)
      绝对 获取读取双重值的方法。
      abstract float getFloat​()
      读取浮点值的相对 get方法。
      abstract float getFloat​(int index)
      用于读取浮点值的绝对 get方法。
      abstract int getInt​()
      用于读取int值的相对 get方法。
      abstract int getInt​(int index)
      用于读取int值的绝对 get方法。
      abstract long getLong​()
      读取长值的相对 get方法。
      abstract long getLong​(int index)
      绝对 获取读取长值的方法。
      abstract short getShort​()
      相对 获取方法读取一个简短的值。
      abstract short getShort​(int index)
      绝对 获取读取一个简短值的方法。
      boolean hasArray​()
      告诉这个缓冲区是否由可访问的字节数组支持。
      int hashCode​()
      返回此缓冲区的当前哈希码。
      abstract boolean isDirect​()
      告诉这个字节缓冲区是否是直接的。
      ByteBuffer limit​(int newLimit)
      设置此缓冲区的限制。
      ByteBuffer mark​()
      将此缓冲区的标记设置在其位置。
      ByteOrder order​()
      检索此缓冲区的字节顺序。
      ByteBuffer order​(ByteOrder bo)
      修改缓冲区的字节顺序。
      ByteBuffer position​(int newPosition)
      设置这个缓冲区的位置。
      abstract ByteBuffer put​(byte b)
      相对 放置(可选操作)
      ByteBuffer put​(byte[] src)
      相对大容量 put方法 (可选操作)
      ByteBuffer put​(byte[] src, int offset, int length)
      相对大容量 put方法 (可选操作)
      abstract ByteBuffer put​(int index, byte b)
      绝对 put方法 (可选操作)
      ByteBuffer put​(ByteBuffer src)
      相对大容量 put方法 (可选操作)
      abstract ByteBuffer putChar​(char value)
      写入char值的相对 put方法 (可选操作)
      abstract ByteBuffer putChar​(int index, char value)
      用于写入char值的绝对 put方法 (可选操作)
      abstract ByteBuffer putDouble​(double value)
      写入double值的相对 put方法 (可选操作)
      abstract ByteBuffer putDouble​(int index, double value)
      用于写入双精度值的绝对 put方法 (可选操作)
      abstract ByteBuffer putFloat​(float value)
      编写浮点值的相对 put方法 (可选操作)
      abstract ByteBuffer putFloat​(int index, float value)
      用于写入浮点值的绝对 put方法 (可选操作)
      abstract ByteBuffer putInt​(int value)
      编写int值的相对 put方法 (可选操作)
      abstract ByteBuffer putInt​(int index, int value)
      用于写入int值的绝对 put方法 (可选操作)
      abstract ByteBuffer putLong​(int index, long value)
      绝对 put方法写入一个长的值 (可选操作)
      abstract ByteBuffer putLong​(long value)
      写入长值的相对 put方法 (可选操作)
      abstract ByteBuffer putShort​(int index, short value)
      绝对 put方法写入一个简短的值 (可选操作)
      abstract ByteBuffer putShort​(short value)
      写入一个短值的相对 放置方法 (可选操作)
      ByteBuffer reset​()
      将此缓冲区的位置重置为先前标记的位置。
      ByteBuffer rewind​()
      倒带这个缓冲区。
      abstract ByteBuffer slice​()
      创建一个新的字节缓冲区,其内容是此缓冲区内容的共享子序列。
      String toString​()
      返回一个汇总此缓冲区状态的字符串。
      static ByteBuffer wrap​(byte[] array)
      将一个字节数组包装到缓冲区中。
      static ByteBuffer wrap​(byte[] array, int offset, int length)
      将一个字节数组包装到缓冲区中。
    • 方法详细信息

      • allocateDirect

        public static ByteBuffer allocateDirect​(int capacity)
        分配一个新的直接字节缓冲区。

        新缓冲区的位置将为零,其限制将为其容量,其标记将不定义,其每个元素将被初始化为零,其字节顺序将为BIG_ENDIAN 是否有一个backing array是未指定的。

        参数
        capacity - 新的缓冲区的容量,以字节为单位
        结果
        新的字节缓冲区
        异常
        IllegalArgumentException - 如果 capacity是负整数
      • allocate

        public static ByteBuffer allocate​(int capacity)
        分配一个新的字节缓冲区。

        新缓冲区的位置将为零,其限制将为其容量,其标记将不定义,其每个元素将被初始化为零,其字节顺序将为BIG_ENDIAN 它将有一个backing array ,其array offset将为零。

        参数
        capacity - 新的缓冲区的容量,以字节为单位
        结果
        新的字节缓冲区
        异常
        IllegalArgumentException - 如果 capacity是负整数
      • wrap

        public static ByteBuffer wrap​(byte[] array,
                                      int offset,
                                      int length)
        将一个字节数组包装到缓冲区中。

        新的缓冲区将由给定的字节数组支持; 也就是说,对缓冲区的修改将导致数组被修改,反之亦然。 新增的缓冲区容量将为array.length ,其位置将为offset ,其限制将为offset + length ,其标记将不定义,其字节顺序为BIG_ENDIAN backing array将是给定的数组,其array offset将为零。

        参数
        array - 将返回新缓冲区的数组
        offset - 要使用的子阵列的偏移量; 必须是非负数,不得大于array.length 新缓冲区的位置将被设置为此值。
        length - 要使用的子阵列的长度; 必须是非负数,不得大于array.length - offset 新缓冲区的限制将设置为offset + length
        结果
        新的字节缓冲区
        异常
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
      • wrap

        public static ByteBuffer wrap​(byte[] array)
        将一个字节数组包装到缓冲区中。

        新的缓冲区将由给定的字节数组支持; 也就是说,对缓冲区的修改将导致数组被修改,反之亦然。 新缓冲区的容量和限制将为array.length ,其位置将为零,其标记将不定义,其字节顺序将为BIG_ENDIAN backing array将是给定的数组,其array offset将为零。

        参数
        array - 将返回此缓冲区的数组
        结果
        新的字节缓冲区
      • slice

        public abstract ByteBuffer slice​()
        创建一个新的字节缓冲区,其内容是此缓冲区内容的共享子序列。

        新缓冲区的内容将从此缓冲区的当前位置开始。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的位置将为零,其容量和限制将是此缓冲区中剩余的字节数,其标记将不定义,其字节顺序将为BIG_ENDIAN 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        Specified by:
        sliceBuffer
        结果
        新的字节缓冲区
        另请参见:
        alignedSlice(int)
      • duplicate

        public abstract ByteBuffer duplicate​()
        创建一个新的字节缓冲区,共享此缓冲区的内容。

        新缓冲区的内容将是这个缓冲区的内容。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的容量,限制,位置和标记值将与该缓冲区的容量,位置和标记值相同,其字节顺序将为BIG_ENDIAN 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        Specified by:
        duplicateBuffer
        结果
        新的字节缓冲区
      • asReadOnlyBuffer

        public abstract ByteBuffer asReadOnlyBuffer​()
        创建一个新的只读字节缓冲区,共享此缓冲区的内容。

        新缓冲区的内容将是这个缓冲区的内容。 这个缓冲区内容的更改将在新的缓冲区中显示; 但是,新的缓冲区本身将是只读的,不允许修改共享内容。 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的容量,限制,位置和标记值将与此缓冲区的容量相同,其字节顺序将为BIG_ENDIAN

        如果这个缓冲区本身是只读的,那么这个方法的行为与duplicate方法完全相同。

        结果
        新的只读字节缓冲区
      • get

        public abstract byte get​()
        相对获取方法。 读取该缓冲区当前位置的字节,然后增加位置。
        结果
        缓冲区当前位置的字节
        异常
        BufferUnderflowException - 如果缓冲区的当前位置不小于其限制
      • put

        public abstract ByteBuffer put​(byte b)
        相对放置(可选操作)

        将给定字节写入当前位置的缓冲区,然后增加位置。

        参数
        b - 要写入的字节
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区的当前位置不小于其限制
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • get

        public abstract byte get​(int index)
        绝对获取方法。 读取给定索引处的字节。
        参数
        index - 读取字节的索引
        结果
        给定索引处的字节
        异常
        IndexOutOfBoundsException - 如果 index为负值或不小于缓冲区限制值
      • put

        public abstract ByteBuffer put​(int index,
                                       byte b)
        绝对put方法(可选操作)

        将给定字节写入给定索引的缓冲区。

        参数
        index - 要写入字节的索引
        b - 要写入的字节值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • get

        public ByteBuffer get​(byte[] dst,
                              int offset,
                              int length)
        相对批量获取方法。

        此方法将字节从此缓冲区传输到给定的目标数组。 如果缓冲区中剩余的字节少于满足请求所需的字节数,即length > remaining() ,则不会传输任何字节,并抛出一个BufferUnderflowException

        否则,该方法将length字节从此缓冲区复制到给定的数组中,从该缓冲区的当前位置开始,并在数组中给定的偏移量。 然后将该缓冲区的位置增加length

        换句话说,这种形式为src.get(dst, off, len)方法的调用与src.get(dst, off, len)具有完全相同的效果

           for (int i = off; i < off + len; i++) dst[i] = src.get():  
        除了它首先检查这个缓冲区中是否有足够的字节,并且它可能更有效率。
        参数
        dst - 要写入字节的数组
        offset - 要写入的第一个字节的数组内的偏移量; 必须是非负数,不得大于dst.length
        length - 要写入给定数组的最大字节数; 必须是非负数,不得大于dst.length - offset
        结果
        这个缓冲区
        异常
        BufferUnderflowException - 如果此缓冲区中剩余的字节少于 length个字节
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
      • get

        public ByteBuffer get​(byte[] dst)
        相对批量获取方法。

        此方法将字节从此缓冲区传输到给定的目标数组。 这种src.get(a)形式的方法的调用与调用的方式完全相同

          src.get(a, 0, a.length) 
        参数
        dst - 目的地阵列
        结果
        这个缓冲区
        异常
        BufferUnderflowException - 如果此缓冲区中剩余的字节少于 length个字节
      • put

        public ByteBuffer put​(ByteBuffer src)
        相对大容量put方法(可选操作)

        此方法将给定源缓冲区中剩余的字节传输到此缓冲区。 如果源缓冲区中剩余的字节多于此缓冲区中的字节数,即src.remaining() > remaining() ,则不会传输任何字节,并抛出BufferOverflowException

        否则,该方法将n = src.remaining()字节从给定缓冲区复制到此缓冲区中,从每个缓冲区的当前位置开始。 然后将两个缓冲器的位置递增n

        换句话说,这种dst.put(src)形式的方法的调用与循环完全相同

          while (src.hasRemaining())
                 dst.put(src.get()); 
        除了它首先检查这个缓冲区中是否有足够的空间,并且它可能更有效率。
        参数
        src - 要读取字节的源缓冲区; 不能是这个缓冲区
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中的源缓冲区中剩余字节的空间不足
        IllegalArgumentException - 如果源缓冲区是这个缓冲区
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • put

        public ByteBuffer put​(byte[] src,
                              int offset,
                              int length)
        相对大容量put方法(可选操作)

        此方法将字节从给定的源数组传输到此缓冲区。 如果从数组中复制的字节数多于保留在该缓冲区中的字节数,即length > remaining() ,则不会传输任何字节,并抛出BufferOverflowException

        否则,该方法将length个字节从给定的数组复制到此缓冲区中,从阵列中的给定偏移量和此缓冲区的当前位置开始。 此缓冲区的位置然后增加length

        换句话说,这种形式为dst.put(src, off, len)方法的调用与dst.put(src, off, len)具有完全相同的效果

           for (int i = off; i < off + len; i++) dst.put(a[i]);  
        除了它首先检查这个缓冲区中是否有足够的空间,并且它可能更有效率。
        参数
        src - 要读取字节的数组
        offset - 要读取的第一个字节的数组中的偏移量; 必须是非负数,不得大于array.length
        length - 从给定数组读取的字节数; 必须是非负数,不得大于array.length - offset
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区空间不足
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • put

        public final ByteBuffer put​(byte[] src)
        相对大容量put方法(可选操作)

        此方法将给定源字节数组的整个内容传输到此缓冲区。 对这种形式为dst.put(a)的方法的调用与调用的方式完全相同

          dst.put(a, 0, a.length) 
        参数
        src - 源数组
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • hasArray

        public final boolean hasArray​()
        告诉这个缓冲区是否由可访问的字节数组支持。

        如果此方法返回true则可以安全地调用arrayarrayOffset方法。

        Specified by:
        hasArray在类 Buffer
        结果
        true如果且仅当此缓冲区由数组支持并且不是只读的
      • array

        public final byte[] array​()
        返回支持此缓冲区的字节数组(可选操作)

        对此缓冲区内容的修改将导致返回的数组的内容被修改,反之亦然。

        在调用此方法之前调用hasArray方法,以确保此缓冲区具有可访问的后台阵列。

        Specified by:
        array中的 Buffer
        结果
        支持这个缓冲区的数组
        异常
        ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
        UnsupportedOperationException - 如果此缓冲区未由可访问阵列支持
      • arrayOffset

        public final int arrayOffset​()
        返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量(可选操作)

        如果缓冲区由数组支持,则缓冲区p对应于数组索引p + arrayOffset()

        在调用此方法之前调用hasArray方法,以确保此缓冲区具有可访问的后台阵列。

        Specified by:
        arrayOffsetBuffer
        结果
        缓冲区的第一个元素的缓冲区数组中的偏移量
        异常
        ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
        UnsupportedOperationException - 如果此缓冲区未由可访问阵列支持
      • position

        public ByteBuffer position​(int newPosition)
        设置这个缓冲区的位置。 如果标记被定义并且大于新位置,则它被丢弃。
        重写:
        positionBuffer
        参数
        newPosition - 新的位置值; 必须是非负数,不得大于当前限制
        结果
        这个缓冲区
      • limit

        public ByteBuffer limit​(int newLimit)
        设置此缓冲区的限制。 如果位置大于新的限制,那么它被设置为新的限制。 如果标记被定义并且大于新限制,则它被丢弃。
        重写:
        limitBuffer
        参数
        newLimit - 新限制值 必须是非负数,不大于此缓冲区的容量
        结果
        这个缓冲区
      • mark

        public ByteBuffer mark​()
        将此缓冲区的标记设置在其位置。
        重写:
        markBuffer
        结果
        这个缓冲区
      • reset

        public ByteBuffer reset​()
        将此缓冲区的位置重置为先前标记的位置。

        调用此方法既不会更改也不丢弃该标记的值。

        重写:
        resetBuffer
        结果
        这个缓冲区
      • clear

        public ByteBuffer clear​()
        清除此缓冲区。 位置设置为零,限制设置为容量,标记被丢弃。

        在使用一系列通道读取或放置操作填充此缓冲区之前调用此方法。 例如:

         buf.clear();     // Prepare buffer for reading
         in.read(buf);    // Read data

        该方法实际上并不会清除缓冲区中的数据,而是将其命名为它的确因为它最常用于情况也是如此。

        重写:
        clear中的 Buffer
        结果
        这个缓冲区
      • flip

        public ByteBuffer flip​()
        翻转这个缓冲区。 该限制设置为当前位置,然后将该位置设置为零。 如果标记被定义,则它被丢弃。

        在通道读取或放置操作的序列之后,调用此方法来准备一系列通道写入或相对获取操作。 例如:

         buf.put(magic);    // Prepend header
         in.read(buf);      // Read data into rest of buffer
         buf.flip();        // Flip buffer
         out.write(buf);    // Write header + data to channel

        当将数据从一个地方传输到另一个地址时,该方法通常与compact方法结合使用。

        重写:
        flipBuffer
        结果
        这个缓冲区
      • rewind

        public ByteBuffer rewind​()
        倒带这个缓冲区。 位置设置为零,标记被丢弃。

        在通道写入或获取操作的序列之前调用此方法,假设已经设置了相应的限制。 例如:

         out.write(buf);    // Write remaining data
         buf.rewind();      // Rewind buffer
         buf.get(array);    // Copy data into array
        重写:
        rewindBuffer
        结果
        这个缓冲区
      • compact

        public abstract ByteBuffer compact​()
        压缩此缓冲区(可选操作)

        缓冲区当前位置与其限制(如果有的话)之间的字节被复制到缓冲区的开头。 即,在索引p =字节position()被复制到索引0,在索引p + 1的字节被复制到索引1,依此类推,直到在索引的字节limit() - 1被复制到索引n = limit() - 1 - p 然后将缓冲区的位置设置为n + 1,并将其限制设置为其容量。 标记如果被定义,则被丢弃。

        缓冲区的位置设置为复制的字节数,而不是零,因此可以通过调用另一个相对put方法来立即调用此方法。

        在写入不完整的情况下从缓冲区写入数据后调用此方法。 例如,以下循环通过缓冲区将字节从一个通道复制到另一个通道buf

        
           buf.clear();          // Prepare buffer for use
           while (in.read(buf) >= 0 || buf.position != 0) {
               buf.flip();
               out.write(buf);
               buf.compact();    // In case of partial write
           }
         
        结果
        这个缓冲区
        异常
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • isDirect

        public abstract boolean isDirect​()
        告诉这个字节缓冲区是否是直接的。
        Specified by:
        isDirectBuffer
        结果
        true如果,并且只有这个缓冲区是直接的
      • toString

        public String toString​()
        返回一个汇总此缓冲区状态的字符串。
        重写:
        toString中的 Object
        结果
        摘要字符串
      • hashCode

        public int hashCode​()
        返回此缓冲区的当前哈希码。

        字节缓冲区的哈希码仅取决于其剩余的元素; 也就是说,元素从position()直到并包括元素在limit() - 1

        因为缓冲区哈希码是内容依赖的,所以使用缓冲区作为哈希映射或类似数据结构中的密钥是不合适的,除非知道它们的内容不会改变。

        重写:
        hashCodeObject
        结果
        这个缓冲区的当前哈希码
        另请参见:
        Object.equals(java.lang.Object)System.identityHashCode(java.lang.Object)
      • equals

        public boolean equals​(Object ob)
        告诉这个缓冲区是否等于另一个对象。

        两个字节的缓冲区是相等的,

        1. 它们具有相同的元素类型,

        2. 他们有相同数量的剩余元素,和

        3. 独立于其起始位置的剩余元素的两个序列是相等的。

        字节缓冲区不等于任何其他类型的对象。

        重写:
        equalsObject
        参数
        ob - 要比较此缓冲区的对象
        结果
        true如果,并且只有当这个缓冲区等于给定的对象
        另请参见:
        Object.hashCode()HashMap
      • compareTo

        public int compareTo​(ByteBuffer that)
        将此缓冲区与另一个缓冲区进

        通过以字面的方式比较其剩余元素的序列来比较两个字节缓冲区,而不考虑其相应缓冲器内每个序列的起始位置。 成对的byte元素比较好像是通过调用Byte.compare(byte,byte)

        一个字节缓冲区不能与任何其他类型的对象相媲美。

        Specified by:
        compareTo接口 Comparable<ByteBuffer>
        参数
        that - 要比较的对象。
        结果
        负整数,零或正整数,因为此缓冲区小于,等于或大于给定的缓冲区
      • order

        public final ByteOrder order​()
        检索此缓冲区的字节顺序。

        读取或写入多字节值时使用字节顺序,当创建作为此字节缓冲区视图的缓冲区时使用。 新创建的字节缓冲区的顺序始终为BIG_ENDIAN

        结果
        这个缓冲区的字节顺序
      • alignmentOffset

        public final int alignmentOffset​(int index,
                                         int unitSize)
        返回内存地址,指向给定索引处的字节,模拟给定的单位大小。

        大于零的返回值表示索引处的字节的地址对于单位大小而不对齐,并且值的数量表示索引应向上或向下四舍五入以在对齐的地址上定位一个字节。 否则,值为0表示索引处的字节的地址对应于单位大小。

        API Note:
        如果本地平台支持,则可以使用该方法来确定来自索引的单元大小字节是否可以被原子访问。
        Implementation Note:
        此实现抛出 UnsupportedOperationException非直接缓冲区时给定的单元尺寸大于 8
        参数
        index - 查询对齐偏移的索引必须是非负的,不执行上限检查
        unitSize - 以字节为单位的单位大小,必须是 2
        结果
        索引字节的内存地址模数单位大小
        异常
        IllegalArgumentException - 如果索引为负数或单位大小不是 2的权力
        UnsupportedOperationException - 如果在管理与该缓冲区(直接或非直接)相同种类的缓冲区的存储区域时,本地平台不能保证给定单元大小的稳定的对齐偏移值。 例如,如果垃圾收集将导致由非直接缓冲区覆盖的存储器区域从一个位置移动到另一个位置,并且两个位置具有不同的对准特性。
        从以下版本开始:
        9
        另请参见:
        alignedSlice(int)
      • alignedSlice

        public final ByteBuffer alignedSlice​(int unitSize)
        创建一个新的字节缓冲区,其内容是此缓冲区内容的共享和对齐子序列。

        新缓冲区的内容将从该缓冲区的当前位置开始,四舍五入到给定单位大小的最近对齐字节的索引,并以该缓冲区的极限结束,舍入到给定单位大小的最近对齐字节的索引。 如果舍入导致超出限制值,则新缓冲区的容量和限制将为零。 如果舍入在边界范围内,新的缓冲区nb和单元大小unitSize的以下表达式将成立:

           nb.alignmentOffset(0, unitSize) == 0 nb.alignmentOffset(nb.limit(), unitSize) == 0  

        对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新的缓冲区的位置将为零,其容量和限制将是此缓冲区中剩余的字节数或更少的对齐方式,其标记将不定义,其字节顺序将为BIG_ENDIAN 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        API Note:
        如果本地平台支持,则可以使用该方法来创建新的缓冲区,其中来自索引的单位大小字节(即单位大小的倍数)可被原子访问。
        Implementation Note:
        此实现抛出 UnsupportedOperationException非直接缓冲区时给定的单元尺寸大于 8
        参数
        unitSize - 以字节为单位的单位大小必须是 2
        结果
        新的字节缓冲区
        异常
        IllegalArgumentException - 如果单位大小不是 2的权力
        UnsupportedOperationException - 如果在管理与该缓冲区(直接或非直接)相同种类的缓冲区的存储器区域时,本地平台不能保证给定单元大小的稳定对齐的片段。 例如,如果垃圾收集将导致由非直接缓冲区覆盖的存储器区域从一个位置移动到另一个位置,并且两个位置具有不同的对准特性。
        从以下版本开始:
        9
        另请参见:
        alignmentOffset(int, int)slice()
      • getChar

        public abstract char getChar​()
        读取char值的相对get方法。

        在此缓冲区的当前位置读取接下来的两个字节,根据当前字节顺序将它们组合成一个char值,然后将位置递增2。

        结果
        缓冲区当前位置的char值
        异常
        BufferUnderflowException - 如果此缓冲区中剩余少于两个字节
      • putChar

        public abstract ByteBuffer putChar​(char value)
        写入char值的相对put方法(可选操作)

        将当前字节顺序中包含给定char值的两个字节写入此缓冲区中的当前位置,然后将位置递增2。

        参数
        value - 要写入的char值
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中剩余少于两个字节
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • getChar

        public abstract char getChar​(int index)
        绝对获取方法来读取一个char值。

        在给定索引处读取两个字节,根据当前字节顺序将它们组合成一个char值。

        参数
        index - 读取字节的索引
        结果
        给定索引处的char值
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则减1
      • putChar

        public abstract ByteBuffer putChar​(int index,
                                           char value)
        用于写入char值的绝对put方法(可选操作)

        将给定的char值的两个字节以当前字节顺序写入给定索引的缓冲区。

        参数
        index - 要写入字节的索引
        value - 要写入的字符值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则减1
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • asCharBuffer

        public abstract CharBuffer asCharBuffer​()
        创建一个字节缓冲区作为char缓冲区的视图。

        新缓冲区的内容将从此缓冲区的当前位置开始。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的位置将为零,其容量和限制将是此缓冲区中剩余的字节数除以2,其标记将不定义,并且其字节顺序将是视图为字节缓冲区的字节顺序创建。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        结果
        一个新的char缓冲区
      • getShort

        public abstract short getShort​()
        相对获取方法读取一个简短的值。

        在该缓冲区的当前位置读取接下来的两个字节,根据当前字节顺序将它们组合成一个短值,然后将位置递增2。

        结果
        缓冲区当前位置的短值
        异常
        BufferUnderflowException - 如果此缓冲区中剩余少于两个字节
      • putShort

        public abstract ByteBuffer putShort​(short value)
        写入一个短值的相对放置方法(可选操作)

        以当前字节顺序将包含给定短值的两个字节写入此缓冲区,然后将位置递增2。

        参数
        value - value的短值
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中剩余少于两个字节
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • getShort

        public abstract short getShort​(int index)
        绝对获取读取一个简短值的方法。

        在给定索引处读取两个字节,根据当前字节顺序将它们组合成一个短值。

        参数
        index - 从中读取字节的索引
        结果
        给定指数的短期价值
        异常
        IndexOutOfBoundsException - 如果 index为负值或不小于缓冲区限制,则减去1
      • putShort

        public abstract ByteBuffer putShort​(int index,
                                            short value)
        绝对put方法写入一个简短的值(可选操作)

        以给定的索引将包含给定短值的两个字节以当前字节顺序写入此缓冲区。

        参数
        index - 要写入字节的索引
        value - value的短价值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则减1
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • asShortBuffer

        public abstract ShortBuffer asShortBuffer​()
        将此字节缓冲区的视图创建为短缓冲区。

        新缓冲区的内容将从此缓冲区的当前位置开始。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的位置将为零,其容量和限制将是此缓冲区中剩余的字节数除以2,其标记将不定义,并且其字节顺序将是视图为字节缓冲区的字节顺序创建。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        结果
        一个新的缓冲区
      • getInt

        public abstract int getInt​()
        用于读取int值的相对get方法。

        在该缓冲区的当前位置读取接下来的四个字节,根据当前字节顺序将它们组合成一个int值,然后将位置递增四。

        结果
        缓冲区当前位置的int值
        异常
        BufferUnderflowException - 如果此缓冲区中剩余少于四个字节
      • putInt

        public abstract ByteBuffer putInt​(int value)
        编写int值的相对put方法(可选操作)

        以当前字节顺序将包含给定int值的四个字节写入当前位置的缓冲区,然后将位置递增四。

        参数
        value - 要写入的int值
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中剩余少于四个字节
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • getInt

        public abstract int getInt​(int index)
        用于读取int值的绝对get方法。

        在给定索引处读取四个字节,根据当前字节顺序将它们组合成一个int值。

        参数
        index - 读取字节的索引
        结果
        给定索引处的int值
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则为负数
      • putInt

        public abstract ByteBuffer putInt​(int index,
                                          int value)
        用于写入int值的绝对put方法(可选操作)

        以给定的索引将包含给定int值的四个字节以当前字节顺序写入此缓冲区。

        参数
        index - 要写入字节的索引
        value - 要写入的int值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负值或不小于缓冲区限制,则减去3
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • asIntBuffer

        public abstract IntBuffer asIntBuffer​()
        将此字节缓冲区的视图创建为int缓冲区。

        新缓冲区的内容将从此缓冲区的当前位置开始。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的位置将为零,其容量和限制将是该缓冲区中剩余的字节数除以4,其标记将不定义,并且其字节顺序将是视图为字节缓冲区的字节顺序创建。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        结果
        一个新的int缓冲区
      • getLong

        public abstract long getLong​()
        读取长值的相对get方法。

        在该缓冲区的当前位置读取接下来的八个字节,根据当前字节顺序将它们组合成一个长的值,然后将位置增加八位。

        结果
        缓冲区当前位置的长值
        异常
        BufferUnderflowException - 如果此缓冲区中剩余少于8个字节
      • putLong

        public abstract ByteBuffer putLong​(long value)
        写入长值的相对put方法(可选操作)

        以当前字节顺序将包含给定长值的八个字节写入当前位置的缓冲区,然后将位置递增8。

        参数
        value - value的长的值
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中剩余少于8个字节
        ReadOnlyBufferException - 如果此缓冲区为只读
      • getLong

        public abstract long getLong​(int index)
        绝对获取读取长值的方法。

        在给定索引处读取八个字节,根据当前字节顺序将它们组合成一个长整型值。

        参数
        index - 读取字节的索引
        结果
        给定指数的长期价值
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则为负数
      • putLong

        public abstract ByteBuffer putLong​(int index,
                                           long value)
        绝对put方法写入一个长的值(可选操作)

        以给定的索引将包含给定long值的八个字节以当前字节顺序写入此缓冲区。

        参数
        index - 要写入字节的索引
        value - value的长的价值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则为负数
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • asLongBuffer

        public abstract LongBuffer asLongBuffer​()
        将此字节缓冲区的视图创建为长缓冲区。

        新缓冲区的内容将从此缓冲区的当前位置开始。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的位置将为零,其容量和限制将是该缓冲区中剩余的字节数除以8,其标记将不定义,并且其字节顺序将是视图为字节缓冲区的字节顺序创建。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        结果
        一个新的长缓冲区
      • getFloat

        public abstract float getFloat​()
        读取浮点值的相对get方法。

        在该缓冲区的当前位置读取接下来的四个字节,根据当前字节顺序将它们组合成一个浮点值,然后将位置递增四。

        结果
        缓冲区当前位置的浮点值
        异常
        BufferUnderflowException - 如果此缓冲区中剩余少于四个字节
      • putFloat

        public abstract ByteBuffer putFloat​(float value)
        编写浮点值的相对put方法(可选操作)

        以当前字节顺序将包含给定浮点值的四个字节写入此缓冲区中的当前位置,然后将位置递增四。

        参数
        value - 要写入的浮点值
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中剩余少于四个字节
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • getFloat

        public abstract float getFloat​(int index)
        用于读取浮点值的绝对get方法。

        在给定索引处读取四个字节,根据当前字节顺序将它们组合成一个浮点值。

        参数
        index - 从中读取字节的索引
        结果
        给定索引处的浮点值
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则减去3
      • putFloat

        public abstract ByteBuffer putFloat​(int index,
                                            float value)
        用于写入浮点值的绝对put方法(可选操作)

        以给定的索引将包含给定浮点值的四个字节以当前字节顺序写入此缓冲区。

        参数
        index - 要写入字节的索引
        value - 要写入的浮点值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则减去3
        ReadOnlyBufferException - 如果此缓冲区为只读
      • asFloatBuffer

        public abstract FloatBuffer asFloatBuffer​()
        将此字节缓冲区的视图创建为浮动缓冲区。

        新缓冲区的内容将从此缓冲区的当前位置开始。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的位置将为零,其容量和限制将是该缓冲区中剩余的字节数除以4,其标记将不定义,并且其字节顺序将是视图为字节缓冲区的字节顺序创建。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        结果
        一个新的浮动缓冲区
      • getDouble

        public abstract double getDouble​()
        读取双重值的相对get方法。

        在该缓冲区的当前位置读取接下来的八个字节,根据当前字节顺序将它们组合成一个双精度值,然后将位置递增8。

        结果
        缓冲区当前位置的double值
        异常
        BufferUnderflowException - 如果此缓冲区中剩余少于8个字节
      • putDouble

        public abstract ByteBuffer putDouble​(double value)
        写入double值的相对put方法(可选操作)

        以当前字节顺序将包含给定双值的八个字节写入当前位置的缓冲区,然后将位置递增8。

        参数
        value - 要写入的双重值
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中剩余少于8个字节
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • getDouble

        public abstract double getDouble​(int index)
        绝对获取读取双重值的方法。

        在给定索引处读取八个字节,根据当前字节顺序将它们组合成双精度值。

        参数
        index - 从中读取字节的索引
        结果
        给定指数的双重值
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则为负数
      • putDouble

        public abstract ByteBuffer putDouble​(int index,
                                             double value)
        用于写入双精度值的绝对put方法(可选操作)

        以给定的索引将包含给定双值的八个字节以当前字节顺序写入此缓冲区。

        参数
        index - 要写入字节的索引
        value - 要写入的双重值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制,则为负数
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • asDoubleBuffer

        public abstract DoubleBuffer asDoubleBuffer​()
        将此字节缓冲区的视图创建为双缓冲区。

        新缓冲区的内容将从此缓冲区的当前位置开始。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的位置将为零,其容量和限制将是该缓冲区中剩余的字节数除以8,其标记将不定义,并且其字节顺序将是视图为字节缓冲区的字节顺序创建。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        结果
        一个新的双缓冲区