CharBuffer

allocate

CharBuffer allocate (int capacity)

分配一个新的字符缓冲区。

新的缓冲区的位置将为零，其限制将是其容量，其标记将是未定义的，并且其每个元素将被初始化为零。 它将有一个 backing array ，其 array offset将为零。

append

CharBuffer append (char c)

将指定的char追加到此缓冲区 （可选操作） 。

表单 dst.append(c)的这种方法的调用与调用完全相同

     dst.put(c) 

append

CharBuffer append (CharSequence csq, 
                int start, 
                int end)

将指定字符序列的子序列附加到此缓冲区 （可选操作） 。

形式的这种方法的调用时 dst.append(csq, start, end) csq不是 null，行为以完全相同的方式调用

     dst.put(csq.subSequence(start, end).toString()) 

append

CharBuffer append (CharSequence csq)

将指定的字符序列追加到此缓冲区 （可选操作） 。

表单 dst.append(csq)的此方法的调用的行为与调用完全相同

     dst.put(csq.toString()) 

取决于toString字符序列csq本说明书中，整个序列可以不追加。 例如，调用字符缓冲区的toString方法将返回一个子序列，其内容取决于缓冲区的位置和限制。

array

char[] array ()

返回支持此缓冲区的char数组 （可选操作） 。

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

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

arrayOffset

int arrayOffset ()

返回缓冲区第一个元素 （可选操作）的此缓冲区的后备数组内的偏移量。

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

在调用此方法之前调用 hasArray方法以确保此缓冲区具有可访问的后备数组。

asReadOnlyBuffer

CharBuffer asReadOnlyBuffer ()

创建一个共享此缓冲区内容的新的只读字符缓冲区。

新缓冲区的内容将是该缓冲区的内容。 此缓冲区内容的更改将在新缓冲区中可见; 但是新的缓冲区本身将是只读的，并且不允许修改共享内容。 两个缓冲区的位置，限制和标记值将是独立的。

新缓冲区的容量，限制，位置和标记值将与该缓冲区的相同。

如果此缓冲区本身是只读的，则此方法的行为方式与 duplicate方法完全相同。

charAt

char charAt (int index)

读取相对于当前位置的给定索引处的字符。

chars

IntStream chars ()

返回int的数据流，从这个序列中扩展char值。 映射到surrogate code point的任何字符都将通过未解释的字符传递。

如果在读取流时序列发生了变化，结果是未定义的。

compact

CharBuffer compact ()

压缩此缓冲区 （可选操作） 。

缓冲区当前位置与其限制之间的字符（如果有）将被复制到缓冲区的开头。 也就是说，索引p = position()处的字符被复制到索引零，索引p + 1处的字符被复制到索引1，依此类推，直到索引limit()-1处的字符被复制到索引n = limit() - 1 - p 。 然后将缓冲区的位置设置为n + 1，并将其限制设置为其容量。 标记（如果已定义）将被丢弃。

The buffer's position is set to the number of chars copied, rather than to zero, so that an invocation of this method can be followed immediately by an invocation of another relative put method.

compareTo

int compareTo (CharBuffer that)

将此缓冲区与另一个进行比较。

通过按照字典顺序比较剩余元素的序列来比较两个char缓冲区，而不考虑每个序列在其相应缓冲区内的开始位置。 对char元素进行比较，就好像调用compare(char, char) 。

字符缓冲区不能与任何其他类型的对象进行比较。

duplicate

CharBuffer duplicate ()

创建一个共享此缓冲区内容的新字符缓冲区。

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

The new buffer's capacity, limit, position, and mark values will be identical to those of this buffer. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.

equals

boolean equals (Object ob)

告诉这个缓冲区是否等于另一个对象。

两个字符缓冲区是相等的，并且只有当，

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

2. 他们有相同数量的剩余元素，并且

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

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

get

char get ()

相对获得方法。 在此缓冲区的当前位置读取char，然后递增该位置。

get

CharBuffer get (char[] dst)

相对批量 获取方法。

该方法将来自此缓冲区的字符传输到给定的目标数组中。 调用表单src.get(a)的此方法的行为与调用完全相同

     src.get(a, 0, a.length) 

get

char get (int index)

Absolute get method. Reads the char at the given index.

get

CharBuffer get (char[] dst, 
                int offset, 
                int length)

相对批量 获取方法。

该方法将来自此缓冲区的字符传输到给定的目标数组中。 如果缓冲区中剩余的字符数少于满足请求所需的字符数，也就是说，如果length > remaining() ，则不会传输字符并引发BufferUnderflowException 。

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

In other words, an invocation of this method of the form src.get(dst, off, len) has exactly the same effect as the loop

     for (int i = off; i < off + len; i++)
         dst[i] = src.get(); 

hasArray

boolean hasArray ()

告诉这个缓冲区是否由可访问的char数组支持。

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

hashCode

int hashCode ()

返回此缓冲区的当前哈希码。

char缓冲区的哈希码仅依赖于其余的元素; 即从position()到元素limit() - 1的元素。

由于缓冲区散列码与内容相关，因此除非知道其内容不会改变，否则在散列映射或类似数据结构中使用缓冲区作为键是不可取的。

isDirect

boolean isDirect ()

告诉这个字符缓冲区是否是直接的。

length

int length ()

返回此字符缓冲区的长度。

当作为字符序列查看时，字符缓冲区的长度只是位置（包括）和限制（不包括）之间的字符数; 也就是说，它相当于remaining() 。

order

ByteOrder order ()

检索此缓冲区的字节顺序。

通过分配或包装现有的char阵列创建的字符缓冲区的字节顺序是底层硬件的 native order 。 创建为字节缓冲区view的字符缓冲区的字节顺序是创建视图时字节缓冲区的字节顺序。

put

CharBuffer put (char[] src)

相对批量 放置方法 （可选操作） 。

此方法将给定源char数组的全部内容传输到此缓冲区中。 表单dst.put(a)的这种方法的调用方式与调用完全相同

     dst.put(a, 0, a.length) 

put

CharBuffer put (int index, 
                char c)

绝对 放置方法 （可选操作） 。

在指定的索引处将给定的char写入此缓冲区。

put

CharBuffer put (CharBuffer src)

相对批量 放置方法 （可选操作） 。

此方法将剩余在给定源缓冲区中的字符传送到此缓冲区。 如果源缓冲区中剩余的字符多于此缓冲区中的字符数，也就是说，如果src.remaining() > remaining() ，则不传送字符并引发BufferOverflowException 。

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

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

     while (src.hasRemaining())
         dst.put(src.get()); 

put

CharBuffer put (String src)

相对批量 放置方法 （可选操作） 。

This method transfers the entire content of the given source string into this buffer. An invocation of this method of the form dst.put(s) behaves in exactly the same way as the invocation

     dst.put(s, 0, s.length()) 

put

CharBuffer put (char c)

相对 放置方法 （可选操作） 。

将给定的char写入当前位置的缓冲区，然后递增该位置。

put

CharBuffer put (String src, 
                int start, 
                int end)

相对批量 放置方法 （可选操作） 。

该方法将chars从给定的字符串传输到此缓冲区。 如果从字符串复制的字符数多于保留在此缓冲区中的字符数，也就是说，如果end - start > remaining() ，则不传送字符并引发BufferOverflowException 。

否则，此方法将n = end - start字符从给定字符串复制到此缓冲区，从给定的start索引开始并在此缓冲区的当前位置开始。 这个缓冲区的位置然后增加n 。

换句话说，调用表单 dst.put(src, start, end)的这种方法与 循环具有完全相同的效果

     for (int i = start; i < end; i++)
         dst.put(src.charAt(i)); 

put

CharBuffer put (char[] src, 
                int offset, 
                int length)

相对批量 放置方法 （可选操作） 。

该方法将chars从给定的源数组传递到此缓冲区。 如果从阵列中复制的字符多于保留在此缓冲区中的字符数，也就是说，如果length > remaining() ，则不传送字符并引发BufferOverflowException 。

否则，该方法会将length字符从给定数组复制到此缓冲区，从数组中给定的偏移量和此缓冲区的当前位置开始。 此缓冲区的位置然后递增length 。

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

     for (int i = off; i < off + len; i++)
         dst.put(a[i]); 

read

int read (CharBuffer target)

尝试将字符读入指定的字符缓冲区。 该缓冲区原样用作字符的存储库：唯一的更改是放置操作的结果。 不执行翻转或倒带缓冲器。

slice

CharBuffer slice ()

创建一个新的字符缓冲区，其内容是此缓冲区内容的共享子序列。

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

新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余字符的数量，其标记将不确定。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

subSequence

CharBuffer subSequence (int start, 
                int end)

创建一个新的字符缓冲区，该缓冲区表示相对于当前位置的此缓冲区的指定子序列。

新缓冲区将共享此缓冲区的内容; 也就是说，如果这个缓冲区的内容是可变的，那么对一个缓冲区的修改会导致另一个缓冲区被修改。 新缓冲区的容量将为该缓冲区的容量，其位置将为position() + start ，其限制将为position() + end 。 当且仅当此缓冲区是直接的时，新缓冲区才是直接的，并且只有在此缓冲区是只读的情况下，它才会是只读的。

toString

String toString ()

返回包含此缓冲区中字符的字符串。

The first character of the resulting string will be the character at this buffer's position, while the last character will be the character at index limit() - 1. Invoking this method does not change the buffer's position.

wrap

CharBuffer wrap (CharSequence csq)

将字符序列包装到缓冲区中。

新的只读缓冲区的内容将是给定字符序列的内容。 新缓冲区的容量和限制将为csq.length() ，其位置将为零，其标记将不确定。

wrap

CharBuffer wrap (char[] array, 
                int offset, 
                int length)

将char数组包装到缓冲区中。

新的缓冲区将由给定的char数组支持; 也就是说，修改缓冲区将导致数组被修改，反之亦然。 新缓冲区容量为array.length ，位置为offset ，限制为offset + length ，其标记为未定义。 它的 backing array将是给定的数组，其 array offset将为零。

wrap

CharBuffer wrap (CharSequence csq, 
                int start, 
                int end)

将字符序列包装到缓冲区中。

新的只读缓冲区的内容将是给定字符序列的内容。 缓冲区容量为csq.length() ，位置为start ，限制为end ，其标记未定义。

wrap

CharBuffer wrap (char[] array)

将char数组包装到缓冲区中。

新的缓冲区将由给定的char数组支持; 也就是说，修改缓冲区将导致数组被修改，反之亦然。 新缓冲区的容量和限制将为array.length ，其位置将为零，并且其标记将不确定。 其 backing array将是给定的数组，其 array offset将为零。