Module  java.base
软件包  java.nio

Class Buffer

  • 已知直接子类：
    ByteBuffer ， CharBuffer ， DoubleBuffer ， FloatBuffer ， IntBuffer ， LongBuffer ， ShortBuffer 

    public abstract class Buffer
extends Object
    用于特定原始类型的数据的容器。

    缓冲器是特定原始类型的元素的线性有限序列。 除了其内容，缓冲区的基本属性是其容量，限制和位置：

    A buffer's capacity is the number of elements it contains. The capacity of a buffer is never negative and never changes.

    A buffer's limit is the index of the first element that should not be read or written. A buffer's limit is never negative and is never greater than its capacity.

    A buffer's position is the index of the next element to be read or written. A buffer's position is never negative and is never greater than its limit.

    每个非布尔基元类型都有这个类的一个子类。

    传输数据

    该类的每个子类定义了两类get和put操作：

    Relative operations read or write one or more elements starting at the current position and then increment the position by the number of elements transferred. If the requested transfer exceeds the limit then a relative get operation throws a BufferUnderflowException and a relative put operation throws a BufferOverflowException; in either case, no data is transferred.

    Absolute operations take an explicit element index and do not affect the position. Absolute get and put operations throw an IndexOutOfBoundsException if the index argument exceeds the limit.

    数据当然也可以通过相对于当前位置的相应通道的I / O操作被传送到或者从缓冲器传送出去。

    标记和重置

    当调用reset方法时，缓冲区的标记是其位置将被重置的索引 。 标记并不总是定义，但是当它被定义时，它不会是负的，并且永远不会大于位置。 如果标记被定义，则当位置或极限被调整为小于标记的值时，它被丢弃。 如果未定义标记，则调用reset方法将导致抛出InvalidMarkException 。

    不变

    标记，位置，极限和容量值的以下不变量保持不变：

    0 <= mark <= position <= limit <= capacity

    新创建的缓冲区始终具有零位置和未定义的标记。 初始限制可以为零，或者可以是取决于缓冲器的类型和构造方式的某些其他值。 新分配的缓冲区的每个元素被初始化为零。

    附加操作

    除了访问位置，限制和容量值以及标记和重置的方法之外，此类还定义了缓冲区上的以下操作：

    • clear()使缓冲区准备好新的通道读取或相对放置操作序列：它将容量和位置的限制设置为零。

    • flip()使缓冲区准备好新的通道写入或相对获取操作序列：它将限制设置为当前位置，然后将位置设置为零。

    • rewind()使缓冲区准备好重新读取它已经包含的数据：它保持限制不变，并将位置设置为零。

    • slice()创建一个缓冲区的子序列：它保留极限和位置不变。

    • duplicate()创建一个缓冲区的浅拷贝：它保留极限和位置不变。

    只读缓冲区

    每个缓冲区都是可读的，但并不是每个缓冲区都是可写的。 每个缓冲区类的变异方法被指定为可选操作 ，当在只读缓冲区上调用时，它将抛出一个ReadOnlyBufferException 。 只读缓冲区不允许更改其内容，但其标记，位置和限制值是可变的。 缓冲区是否为只读可以通过调用其isReadOnly方法来确定。

    线程安全

    缓冲区不能安全地被多个并发线程使用。 如果一个缓冲区被多个线程使用，则应该通过适当的同步来控制对缓冲区的访问。

    调用链接

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

     b.flip();
 b.position(23);
 b.limit(42);
    可以由单一，更紧凑的语句替代 
     b.flip().position(23).limit(42);
    从以下版本开始：
    1.4

    • 方法摘要

      所有方法  接口方法  抽象方法  具体的方法 
      Modifier and Type 方法 描述
      abstract Object array​()
      返回支持此缓冲区的数组 （可选操作） 。
      abstract int arrayOffset​()
      返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量 （可选操作） 。
      int capacity​()
      返回此缓冲区的容量。
      Buffer clear​()
      清除此缓冲区。
      abstract Buffer duplicate​()
      创建一个共享此缓冲区内容的新缓冲区。
      Buffer flip​()
      翻转这个缓冲区。
      abstract boolean hasArray​()
      告诉这个缓冲区是否由可访问的数组支持。
      boolean hasRemaining​()
      告诉当前位置和极限之间是否存在任何元素。
      abstract boolean isDirect​()
      告诉这个缓冲区是否是 direct 。
      abstract boolean isReadOnly​()
      告知这个缓冲区是否是只读的。
      int limit​()
      返回此缓冲区的限制。
      Buffer limit​(int newLimit)
      设置此缓冲区的限制。
      Buffer mark​()
      将此缓冲区的标记设置在其位置。
      int position​()
      返回此缓冲区的位置。
      Buffer position​(int newPosition)
      设置这个缓冲区的位置。
      int remaining​()
      返回当前位置和限制之间的元素数。
      Buffer reset​()
      将此缓冲区的位置重置为先前标记的位置。
      Buffer rewind​()
      倒带这个缓冲区。
      abstract Buffer slice​()
      创建一个新的缓冲区，其内容是此缓冲区内容的共享子序列。

    • 方法详细信息

      • capacity

        public final int capacity​()
        返回此缓冲区的容量。
        结果
        这个缓冲区的容量

      • position

        public final int position​()
        返回此缓冲区的位置。
        结果
        这个缓冲区的位置

      • position

        public Buffer position​(int newPosition)
        设置这个缓冲区的位置。 如果标记被定义并且大于新位置，则它被丢弃。
        参数
        newPosition - 新位置值; 必须是非负数，不得大于当前限制
        结果
        这个缓冲区
        异常
        IllegalArgumentException -如果前提 newPosition不成立

      • limit

        public final int limit​()
        返回此缓冲区的限制。
        结果
        这个缓冲区的极限

      • limit

        public Buffer limit​(int newLimit)
        设置此缓冲区的限制。 如果位置大于新的限制，那么它被设置为新的限制。 如果标记被定义并且大于新限制，则它被丢弃。
        参数
        newLimit - 新限制值; 必须是非负数，不大于此缓冲区的容量
        结果
        这个缓冲区
        异常
        IllegalArgumentException -如果前提 newLimit不成立

      • mark

        public Buffer mark​()
        将此缓冲区的标记设置在其位置。
        结果
        这个缓冲区

      • reset

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

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

        结果
        这个缓冲区
        异常
        InvalidMarkException - 如果标记尚未设置

      • clear

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

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

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

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

        结果
        这个缓冲区

      • flip

        public Buffer 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方法结合使用。

        结果
        这个缓冲区

      • rewind

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

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

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

      • remaining

        public final int remaining​()
        返回当前位置和限制之间的元素数。
        结果
        此缓冲区中剩余的元素数

      • hasRemaining

        public final boolean hasRemaining​()
        告诉当前位置和极限之间是否存在任何元素。
        结果
        true如果，并且只有在此缓冲区中至少有一个元素

      • isReadOnly

        public abstract boolean isReadOnly​()
        告知这个缓冲区是否是只读的。
        结果
        true如果，并且只有这个缓冲区是只读的

      • hasArray

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

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

        结果
        true如果，且仅当此缓冲区由数组支持并且不是只读
        从以下版本开始：
        1.6

      • array

        public abstract Object array​()
        返回支持此缓冲区的数组（可选操作） 。

        该方法旨在使阵列支持的缓冲区更有效地传递到本地代码。 具体的子类为此方法提供了更强类型的返回值。

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

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

        结果
        支持这个缓冲区的数组
        异常
        ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
        UnsupportedOperationException - 如果此缓冲区未由可访问阵列支持
        从以下版本开始：
        1.6

      • arrayOffset

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

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

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

        结果
        缓冲区的第一个元素的缓冲区数组中的偏移量
        异常
        ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
        UnsupportedOperationException - 如果此缓冲区未由可访问阵列支持
        从以下版本开始：
        1.6

      • isDirect

        public abstract boolean isDirect​()
        告诉这个缓冲区是否是 direct 。
        结果
        true如果，并且只有这个缓冲区是直接的
        从以下版本开始：
        1.6

      • slice

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

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

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

        结果
        新的缓冲区
        从以下版本开始：
        9

      • duplicate

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

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

        新缓冲区的容量，限制，位置和标记值将与此缓冲区的容量相同。 如果只有这个缓冲区是直接的，并且只有当这个缓冲区是只读的时，这个缓冲区将是只读的。

        结果
        新的缓冲区
        从以下版本开始：
        9