实现的所有接口

Appendable ， CharSequence ， Comparable<CharBuffer> ， Readable
```
public abstract class CharBufferextends Bufferimplements Comparable<CharBuffer>, Appendable, CharSequence, Readable
```
一个char缓冲区。
该类在char缓冲区中定义了四类操作：
- 读写单个字符的绝对和相对get和put方法;
- 相对bulk get方法，将连续的chars序列从此缓冲区转移到数组中; 和
- 相对bulk put方法将char的连续序列从char数组，字符串或其他char缓冲区转移到此缓冲区中; 和
- compacting char缓冲区的方法。
字符缓冲区可以由allocation创建，它为缓冲区的内容分配空间， wrapping将现有字符串数组或字符串分配到缓冲区中，或者通过创建现有字节缓冲区的view来创建。

像字节缓冲区一样，char缓冲区是direct or non-direct 。通过wrap方法创建的char缓冲区将是非直接的。当且仅当字节缓冲区本身是直接的时，作为字节缓冲区视图创建的字符缓冲区才是直接的。可以通过调用isDirect方法来确定char缓冲区是否是直接的。

此类实现CharSequence接口，以便可以在接受字符序列的任何位置使用字符缓冲区，例如在regular-expression包java.util.regex中。

此类中没有返回值的方法被指定为返回调用它们的缓冲区。这允许链接方法调用。陈述的顺序
```
 cb.put("text/"); cb.put(subtype); cb.put("; charset="); cb.put(enc);
```
例如，可以用单个语句替换
```
 cb.put("text/").put(subtype).put("; charset=").put(enc);
```
从以下版本开始：

1.4

方法摘要

所有方法静态方法实例方法抽象方法具体的方法
变量和类型	方法	描述
`static CharBuffer`	`allocate(int capacity)`	分配一个新的char缓冲区。
`CharBuffer`	`append(char c)`	将指定的char追加到此缓冲区（可选操作）。
`CharBuffer`	`append(CharSequence csq)`	将指定的字符序列追加到此缓冲区（可选操作）。
`CharBuffer`	`append(CharSequence csq, int start, int end)`	将指定字符序列的子序列追加到此缓冲区（可选操作）。
`char[]`	`array()`	返回支持此缓冲区的char数组（可选操作）。
`int`	`arrayOffset()`	返回此缓冲区缓冲区第一个元素的后备数组中的偏移量（可选操作）。
`abstract CharBuffer`	`asReadOnlyBuffer()`	创建一个共享此缓冲区内容的新的只读char缓冲区。
`char`	`charAt(int index)`	读取相对于当前位置的给定索引处的字符。
`abstract CharBuffer`	`compact()`	压缩此缓冲区（可选操作）。
`int`	`compareTo(CharBuffer that)`	比较此缓冲区与另一个缓冲区。
`abstract CharBuffer`	`duplicate()`	创建一个共享此缓冲区内容的新char缓冲区。
`boolean`	`equals(Object ob)`	判断此缓冲区是否等于另一个对象。
`abstract char`	`get()`	相对 get方法。
`CharBuffer`	`get(char[] dst)`	相对批量获取方法。
`CharBuffer`	`get(char[] dst, int offset, int length)`	相对批量获取方法。
`abstract char`	`get(int index)`	绝对获取方法。
`boolean`	`hasArray()`	判断此缓冲区是否由可访问的char数组支持。
`int`	`hashCode()`	返回此缓冲区的当前哈希码。
`abstract boolean`	`isDirect()`	判断此char缓冲区是否是直接的。
`int`	`length()`	返回此字符缓冲区的长度。
`int`	`mismatch(CharBuffer that)`	查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。
`abstract ByteOrder`	`order()`	检索此缓冲区的字节顺序。
`abstract CharBuffer`	`put(char c)`	相对 put方法（可选操作）。
`CharBuffer`	`put(char[] src)`	相对批量放置方法（可选操作）。
`CharBuffer`	`put(char[] src, int offset, int length)`	相对批量放置方法（可选操作）。
`abstract CharBuffer`	`put(int index, char c)`	绝对放法（可选操作）。
`CharBuffer`	`put(String src)`	相对批量放置方法（可选操作）。
`CharBuffer`	`put(String src, int start, int end)`	相对批量放置方法（可选操作）。
`CharBuffer`	`put(CharBuffer src)`	相对批量放置方法（可选操作）。
`int`	`read(CharBuffer target)`	尝试将字符读入指定的字符缓冲区。
`abstract CharBuffer`	`slice()`	创建一个新的char缓冲区，其内容是此缓冲区内容的共享子序列。
`abstract CharBuffer`	`subSequence(int start, int end)`	创建一个新的字符缓冲区，表示此缓冲区相对于当前位置的指定子序列。
`String`	`toString()`	返回包含此缓冲区中字符的字符串。
`static CharBuffer`	`wrap(char[] array)`	将char数组包装到缓冲区中。
`static CharBuffer`	`wrap(char[] array, int offset, int length)`	将char数组包装到缓冲区中。
`static CharBuffer`	`wrap(CharSequence csq)`	将字符序列包装到缓冲区中。
`static CharBuffer`	`wrap(CharSequence csq, int start, int end)`	将字符序列包装到缓冲区中。

声明方法的类 java.nio.Buffer
capacity, clear, flip, hasRemaining, isReadOnly, limit, limit, mark, position, position, remaining, reset, rewind

声明方法的类 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

声明方法的接口 java.lang.CharSequence
chars, codePoints

- 方法详细信息
  - allocate
```
public static CharBuffer allocate(int capacity)
```
    分配一个新的char缓冲区。
    新缓冲区的位置将为零，其限制将是其容量，其标记将是未定义的，其每个元素将初始化为零，其字节顺序将为底层硬件的native order 。它将有一个backing array ，它的array offset将为零。
    
    参数
    
    capacity - 新缓冲区的容量，以字符为单位
    
    结果
    
    新的char缓冲区
    
    异常
    
    IllegalArgumentException - 如果 capacity是负整数
  - wrap
```
public static CharBuffer wrap(char[] array,                              int offset,                              int length)
```
    将char数组包装到缓冲区中。
    新缓冲区将由给定的char数组支持; 也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量将为array.length ，其位置将为offset ，其限制将为offset + length ，其标记将是未定义的，其字节顺序将为底层硬件的native order 。它的backing array将是给定的数组，其array offset将为零。
    
    参数
    
    array - 将支持新缓冲区的数组
    
    offset - 要使用的子阵列的偏移量; 必须是非负数且不大于array.length 。新缓冲区的位置将设置为此值。
    
    length - 要使用的子阵列的长度; 必须是非负数且不大于array.length - offset 。新缓冲区的限制将设置为offset + length 。
    
    结果
    
    新的char缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立
  - wrap
```
public static CharBuffer wrap(char[] array)
```
    将char数组包装到缓冲区中。
    新缓冲区将由给定的char数组支持; 也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量和限制将为array.length ，其位置将为零，其标记将是未定义的，其字节顺序将为底层硬件的native order 。它的backing array将是给定的数组，其array offset将为零。
    
    参数
    
    array - 将支持此缓冲区的数组
    
    结果
    
    新的char缓冲区
  - read
```
public int read(CharBuffer target)         throws IOException
```
    尝试将字符读入指定的字符缓冲区。缓冲区按原样用作字符存储库：唯一的更改是put操作的结果。不执行缓冲器的翻转或倒带。
    
    Specified by:
    
    read在界面 Readable
    
    参数
    
    target - 将字符读入的缓冲区
    
    结果
    
    添加到缓冲区的字符数，如果此字符源位于其末尾，则为-1
    
    异常
    
    IOException - 如果发生I / O错误
    
    NullPointerException - 如果target为null
    
    ReadOnlyBufferException - 如果target是只读缓冲区
    
    从以下版本开始：
    
    1.5
  - wrap
```
public static CharBuffer wrap(CharSequence csq,                              int start,                              int end)
```
    将字符序列包装到缓冲区中。
    新的只读缓冲区的内容将是给定字符序列的内容。缓冲区的容量为csq.length() ，其仓位为start ，其限价为end ，其标记将不确定。
    
    参数
    
    csq - 要从中创建新字符缓冲区的字符序列
    
    start - 要使用的第一个字符的索引; 必须是非负数且不大于csq.length() 。新缓冲区的位置将设置为此值。
    
    end - 要使用的最后一个字符后面的字符的索引; 必须不小于start且不大于csq.length() 。新缓冲区的限制将设置为此值。
    
    结果
    
    新的字符缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 start和 end参数的前提条件不成立
  - wrap
```
public static CharBuffer wrap(CharSequence csq)
```
    将字符序列包装到缓冲区中。
    新的只读缓冲区的内容将是给定字符序列的内容。新缓冲区的容量和限制将为csq.length() ，其位置将为零，其标记将不确定。
    
    参数
    
    csq - 要从中创建新字符缓冲区的字符序列
    
    结果
    
    新的字符缓冲区
  - slice
```
public abstract CharBuffer slice()
```
    创建一个新的char缓冲区，其内容是此缓冲区内容的共享子序列。
    新缓冲区的内容将从此缓冲区的当前位置开始。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字符数，其标记将是未定义的，其字节顺序将与此缓冲区的字节顺序相同。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    Specified by:
    
    slice在类 Buffer
    
    结果
    
    新的char缓冲区
  - duplicate
```
public abstract CharBuffer duplicate()
```
    创建一个共享此缓冲区内容的新char缓冲区。
    新缓冲区的内容将是此缓冲区的内容。对此缓冲区内容的更改将在新缓冲区中可见，反之亦然; 两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的容量，限制，位置，标记值和字节顺序将与此缓冲区的容量，限制，位置，标记值和字节顺序相同。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    Specified by:
    
    duplicate在类 Buffer
    
    结果
    
    新的char缓冲区
  - asReadOnlyBuffer
```
public abstract CharBuffer asReadOnlyBuffer()
```
    创建一个共享此缓冲区内容的新的只读char缓冲区。
    新缓冲区的内容将是此缓冲区的内容。对此缓冲区内容的更改将在新缓冲区中可见; 但是，新缓冲区本身将是只读的，不允许修改共享内容。两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的容量，限制，位置，标记值和字节顺序将与此缓冲区的容量，限制，位置，标记值和字节顺序相同。
    
    如果此缓冲区本身是只读的，则此方法的行为方式与duplicate方法完全相同。
    
    结果
    
    新的只读字符缓冲区
  - get
```
public abstract char get()
```
    相对get方法。读取此缓冲区当前位置的char，然后递增位置。
    
    结果
    
    缓冲区当前位置的字符
    
    异常
    
    BufferUnderflowException - 如果缓冲区的当前位置不小于其限制
  - put
```
public abstract CharBuffer put(char c)
```
    相对put方法（可选操作） 。
    将给定的char写入当前位置的缓冲区，然后递增位置。
    
    参数
    
    c - c的字符
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区的当前位置不小于其限制
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - get
```
public abstract char get(int index)
```
    绝对获取方法。读取给定索引处的char。
    
    参数
    
    index - 将从中读取char的索引
    
    结果
    
    给定索引处的char
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制
  - put
```
public abstract CharBuffer put(int index,                               char c)
```
    绝对放法（可选操作） 。
    将给定的char写入给定索引处的此缓冲区。
    
    参数
    
    index - 将写入char的索引
    
    c - 要写入的char值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - get
```
public CharBuffer get(char[] 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 - 要写入的第一个char的数组中的偏移量; 必须是非负数且不大于dst.length
    
    length - 要写入给定数组的最大字符数; 必须是非负数且不大于dst.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字符数少于 length
    
    IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立
  - get
```
public CharBuffer get(char[] dst)
```
    相对批量获取方法。
    此方法将字符从此缓冲区传输到给定的目标数组。调用src.get(a)形式的此方法的行为与调用的方式完全相同
    
    src.get(a, 0, a.length)
    参数
    
    dst - 目标阵列
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException - 如果此缓冲区中剩余的字符数少于 length
  - put
```
public CharBuffer put(CharBuffer src)
```
    相对批量放置方法（可选操作） 。
    此方法将剩余在给定源缓冲区中的字符传输到此缓冲区中。如果源缓冲区中剩余的字符数多于此缓冲区中的字符数，即src.remaining() > remaining() ，则不会传输字符并抛出BufferOverflowException 。
    
    否则，此方法从给定缓冲区将n = src.remaining()字符复制到此缓冲区中，从每个缓冲区的当前位置开始。然后两个缓冲区的位置增加n 。
    
    换句话说，调用dst.put(src)形式的此方法与dst.put(src)具有完全相同的效果
    
    while (src.hasRemaining()) dst.put(src.get());
    除了它首先检查此缓冲区中是否有足够的空间，它可能更有效。
    参数
    
    src - 要从中读取字符的源缓冲区; 一定不能是这个缓冲区
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间用于源缓冲区中的剩余字符
    
    IllegalArgumentException - 如果源缓冲区是此缓冲区
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - put
```
public CharBuffer put(char[] src,                      int offset,                      int length)
```
    相对批量放置方法（可选操作） 。
    此方法将字符从给定的源数组传输到此缓冲区。如果要从数组中复制的字符数多于保留在此缓冲区中的字符数，即length > remaining() ，则不会传输字符并抛出BufferOverflowException 。
    
    否则，此方法length定数组中的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 - 要读取的第一个char的数组中的偏移量; 必须是非负数且不大于array.length
    
    length - 要从给定数组中读取的字符数; 必须是非负数且不大于array.length - offset
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - put
```
public final CharBuffer put(char[] src)
```
    相对批量放置方法（可选操作） 。
    此方法将给定源char数组的整个内容传输到此缓冲区。调用dst.put(a)形式的此方法的行为与调用的方式完全相同
    
    dst.put(a, 0, a.length)
    参数
    
    src - 源数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - put
```
public CharBuffer put(String src,                      int start,                      int end)
```
    相对批量放置方法（可选操作） 。
    此方法将字符从给定字符串传输到此缓冲区。如果要从字符串中复制的字符数多于保留在此缓冲区中的字符数，即end - start > remaining() ，则不会传输字符并抛出BufferOverflowException 。
    
    否则，此方法复制n = end - start从给定字符串字符到该缓冲区中，从给定的start索引，并且在该缓冲器的当前位置。然后将该缓冲区的位置增加n 。
    
    换句话说，调用dst.put(src, start, end)形式的此方法与dst.put(src, start, end)具有完全相同的效果
    
    for (int i = start; i < end; i++) dst.put(src.charAt(i));
    除了它首先检查此缓冲区中是否有足够的空间，它可能更有效。
    参数
    
    src - 要从中读取字符的字符串
    
    start - 要读取的第一个字符串的字符串中的偏移量; 必须是非负数且不大于string.length()
    
    end - 要读取的最后一个字符串的字符串中的偏移量加一; 必须是非负数且不大于string.length()
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    IndexOutOfBoundsException - 如果 start和 end参数的前提条件不成立
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - put
```
public final CharBuffer put(String src)
```
    相对批量放置方法（可选操作） 。
    此方法将给定源字符串的整个内容传输到此缓冲区。调用dst.put(s)形式的此方法的行为与调用的方式完全相同
    
    dst.put(s, 0, s.length())
    参数
    
    src - 源字符串
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - hasArray
```
public final boolean hasArray()
```
    判断此缓冲区是否由可访问的char数组支持。
    如果此方法返回true则可以安全地调用array和arrayOffset方法。
    
    Specified by:
    
    hasArray在类 Buffer
    
    结果
    
    true当且仅当此缓冲区由数组支持且不是只读时
  - array
```
public final char[] array()
```
    返回支持此缓冲区的char数组（可选操作） 。
    修改此缓冲区的内容将导致返回的数组内容被修改，反之亦然。
    
    在调用此方法之前调用hasArray方法，以确保此缓冲区具有可访问的后备阵列。
    
    Specified by:
    
    array在类 Buffer
    
    结果
    
    支持此缓冲区的数组
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
    
    UnsupportedOperationException - 如果此缓冲区未由可访问的阵列支持
  - arrayOffset
```
public final int arrayOffset()
```
    返回此缓冲区缓冲区第一个元素的后备数组中的偏移量（可选操作） 。
    如果此缓冲区由数组支持，则缓冲区位置p对应于数组索引p + arrayOffset() 。
    
    在调用此方法之前调用hasArray方法，以确保此缓冲区具有可访问的后备阵列。
    
    Specified by:
    
    arrayOffset在类 Buffer
    
    结果
    
    缓冲区第一个元素的缓冲区数组中的偏移量
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
    
    UnsupportedOperationException - 如果此缓冲区未由可访问的阵列支持
  - compact
```
public abstract CharBuffer compact()
```
    压缩此缓冲区（可选操作） 。
    缓冲区当前位置与其限制之间的字符（如果有）将复制到缓冲区的开头。也就是说，索引p = position()处的char被复制到索引0，索引p + 1处的char被复制到索引1，依此类推，直到将索引limit()处的char复制到索引n = limit() - 1 - p 。然后将缓冲区的位置设置为n + 1，并将其限制设置为其容量。标记（如果已定义）将被丢弃。
    
    缓冲区的位置设置为复制的字符数，而不是零，因此可以通过调用另一个相对put方法立即调用此方法。
    
    结果
    
    这个缓冲区
    
    异常
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
  - isDirect
```
public abstract boolean isDirect()
```
    判断此char缓冲区是否是直接的。
    
    Specified by:
    
    isDirect在类 Buffer
    
    结果
    
    true当且仅当此缓冲区是直接的
  - hashCode
```
public int hashCode()
```
    返回此缓冲区的当前哈希码。
    char缓冲区的哈希码仅取决于其剩余的元素; 也就是说，来自position()的元素直到并包括元素limit() - 1 。
    
    因为缓冲区哈希码是依赖于内容的，所以不建议使用缓冲区作为哈希映射或类似数据结构中的键，除非已知它们的内容不会改变。
    
    重写：
    
    hashCode在类 Object
    
    结果
    
    此缓冲区的当前哈希码
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(Object ob)
```
    判断此缓冲区是否等于另一个对象。
    两个char缓冲区相等，当且仅当，
    
    它们具有相同的元素类型，
    
    它们具有相同数量的剩余元素，并且
    
    与其起始位置无关地考虑的两个剩余元素序列是逐点相等的。
    
    char缓冲区不等于任何其他类型的对象。
    重写：
    
    equals在类 Object
    
    参数
    
    ob - 要与此缓冲区进行比较的对象
    
    结果
    
    true当且仅当此缓冲区等于给定对象时
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - compareTo
```
public int compareTo(CharBuffer that)
```
    比较此缓冲区与另一个缓冲区。
    通过按字典顺序比较它们的剩余元素序列来比较两个char缓冲区，而不考虑每个序列在其相应缓冲区内的起始位置。成对的char元素通过调用Character.compare(char,char)进行比较。
    
    char缓冲区与任何其他类型的对象都不具有可比性。
    
    Specified by:
    
    compareTo在界面 Comparable<CharBuffer>
    
    参数
    
    that - 要比较的对象。
    
    结果
    
    此缓冲区小于，等于或大于给定缓冲区的负整数，零或正整数
  - mismatch
```
public int mismatch(CharBuffer that)
```
    查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。索引相对于每个缓冲区的position ，并且将在0（包括）范围内，直到每个缓冲区中的较小的remaining元素（不包括）。
    如果两个缓冲区共享一个公共前缀，则返回的索引是公共前缀的长度，并且随后在相应缓冲区内该索引处的两个缓冲区之间存在不匹配。如果一个缓冲区是另一个缓冲区的正确前缀，则返回的索引是每个缓冲区中剩余元素中较小的一个，并且随后索引仅对具有较多剩余元素的缓冲区有效。否则，没有不匹配。
    
    参数
    
    that - 要测试与此缓冲区不匹配的字节缓冲区
    
    结果
    
    此与给定缓冲区之间的第一个不匹配的相对索引，否则为-1，如果没有不匹配。
    
    从以下版本开始：
    
    11
  - toString
```
public String toString()
```
    返回包含此缓冲区中字符的字符串。
    结果字符串的第一个字符将是此缓冲区位置的字符，而最后一个字符将是索引limit()处的字符 - 1.调用此方法不会更改缓冲区的位置。
    
    Specified by:
    
    toString在界面 CharSequence
    
    重写：
    
    toString在类 Object
    
    结果
    
    指定的字符串
  - length
```
public final int length()
```
    返回此字符缓冲区的长度。
    当作为字符序列查看时，字符缓冲区的长度只是位置（包括）和限制（不包括）之间的字符数; 也就是说，它相当于remaining() 。
    
    Specified by:
    
    length在界面 CharSequence
    
    结果
    
    此字符缓冲区的长度
  - charAt
```
public final char charAt(int index)
```
    读取相对于当前位置的给定索引处的字符。
    
    Specified by:
    
    charAt在接口 CharSequence
    
    参数
    
    index - 要读取的字符的索引，相对于位置; 必须是非负数且小于remaining()
    
    结果
    
    索引号为 position() + index的字符
    
    异常
    
    IndexOutOfBoundsException -如果前提 index不成立
  - subSequence
```
public abstract CharBuffer subSequence(int start,                                       int end)
```
    创建一个新的字符缓冲区，表示此缓冲区相对于当前位置的指定子序列。
    新缓冲区将共享此缓冲区的内容; 也就是说，如果此缓冲区的内容是可变的，那么对一个缓冲区的修改将导致另一个缓冲区被修改。新缓冲区的容量将是此缓冲区的容量，其位置将为position() + start ，其限制将为position() + end 。当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。
    
    Specified by:
    
    subSequence在界面 CharSequence
    
    参数
    
    start - 子序列中第一个字符相对于当前位置的索引; 必须是非负数且不大于remaining()
    
    end - 子序列中最后一个字符后面的字符相对于当前位置的索引; 必须不小于start且不大于remaining()
    
    结果
    
    新的字符缓冲区
    
    异常
    
    IndexOutOfBoundsException - 如果 start和 end的前提条件不成立
  - append
```
public CharBuffer append(CharSequence csq)
```
    将指定的字符序列追加到此缓冲区（可选操作） 。
    调用dst.append(csq)形式的此方法的行为与调用的方式完全相同
    
    dst.put(csq.toString())
    
    取决于规范toString字符序列csq ，整个序列可以不追加。例如，调用字符缓冲区的toString方法将返回一个子序列，其内容取决于缓冲区的位置和限制。
    Specified by:
    
    append在接口 Appendable
    
    参数
    
    csq - 要追加的字符序列。如果csq是null ，则四个字符"null"将附加到此字符缓冲区。
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
    
    从以下版本开始：
    
    1.5
  - append
```
public CharBuffer append(CharSequence csq,                         int start,                         int end)
```
    将指定字符序列的子序列追加到此缓冲区（可选操作） 。
    形式的这种方法的调用dst.append(csq, start, end)时csq不是null ，行为以完全相同的方式调用
    
    dst.put(csq.subSequence(start, end).toString())
    Specified by:
    
    append在界面 Appendable
    
    参数
    
    csq - 将附加子序列的字符序列。如果csq是null ，则将附加字符，就像csq包含四个字符"null" 。
    
    start - 子序列中第一个字符的索引
    
    end - 子序列中最后一个字符后面的字符的索引
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    IndexOutOfBoundsException - 如果 start或 end为负数，则 start大于 end ，或 end大于 csq.length()
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
    
    从以下版本开始：
    
    1.5
  - append
```
public CharBuffer append(char c)
```
    将指定的char追加到此缓冲区（可选操作） 。
    调用dst.append(c)形式的此方法的行为与调用的方式完全相同
    
    dst.put(c)
    Specified by:
    
    append在接口 Appendable
    
    参数
    
    c - 要追加的16位字符
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException - 如果此缓冲区中没有足够的空间
    
    ReadOnlyBufferException - 如果此缓冲区是只读的
    
    从以下版本开始：
    
    1.5
  - order
```
public abstract ByteOrder order()
```
    检索此缓冲区的字节顺序。
    通过分配或通过包装现有char阵列创建的char缓冲区的字节顺序是底层硬件的native order 。作为字节缓冲区的view创建的字符缓冲区的字节顺序是创建视图时字节缓冲区的字节顺序。
    
    结果
    
    此缓冲区的字节顺序

Class CharBuffer

方法摘要

声明方法的类 java.nio.Buffer

声明方法的类 java.lang.Object

声明方法的接口 java.lang.CharSequence

方法详细信息

allocate

wrap

wrap

read

wrap

wrap

slice

duplicate

asReadOnlyBuffer

get

put

get

put

get

get

put

put

put

put

put

hasArray

array

arrayOffset

compact

isDirect

hashCode

equals

compareTo

mismatch

toString

length

charAt

subSequence

append

append

append

order