CharBuffer (Java Platform SE 8 )

java.lang.Object
- java.nio.Buffer
- - java.nio.CharBuffer

All Implemented Interfaces:

Appendable， CharSequence， Comparable < CharBuffer >， Readable
```
public abstract class CharBuffer
extends Buffer
implements Comparable<CharBuffer>, Appendable, CharSequence, Readable
```
字符缓冲区。
这个类定义了字符缓冲区上的四个操作类别：
- 绝对和相对get和put方法读写单字符；
- 相对bulk get方法传递的字符连续序列到一个数组和缓冲区；
- 相对bulk put方法传递的字符连续序列从一个char数组，字符串，或一些其他的字符串缓冲区到缓冲区；和
- 对于compacting，duplicating方法，和slicing字符缓冲区。
字符缓冲区可以创建由allocation，分配的缓冲区的内容空间，通过wrapping现有字符数组和字符串到一个缓冲区，或创建一个view现有的字节缓冲区。

像一个字节的缓冲区，缓冲区是direct or non-direct char。一个字符串缓冲区通过创建这个类的wrap方法将非直接。创建一个字节缓冲区的一个字符缓冲区将是直接的，如果，只有当字节缓冲区本身是直接的。是否一个字符串缓冲区是直接可以通过调用isDirect法测定。

该类实现了CharSequence界面，字符缓冲区可用于任何字符序列被接受，例如在正则表达式包java.util.regex。

在这个类中，不以其他方式有一个返回的值被指定返回它们被调用的缓冲区。这允许方法调用被。语句序列
```
 cb.put("text/");
 cb.put(subtype);
 cb.put("; charset=");
 cb.put(enc);
```
可以，例如，由单个语句
```
 cb.put("text/").put(subtype).put("; charset=").put(enc);
```
取代
从以下版本开始：

一点四

方法摘要

所有方法静态方法接口方法抽象方法具体的方法
Modifier and Type	Method and Description
`static CharBuffer`	`allocate(int capacity)` 分配一个新的字符缓冲区。
`CharBuffer`	`append(char c)` 将指定的字符缓冲区（可选操作）。
`CharBuffer`	`append(CharSequence csq)` 将指定的字符序列，这个缓冲区（可选操作）。
`CharBuffer`	`append(CharSequence csq, int start, int end)` 添加一个序列指定的字符序列，这个缓冲区（可选操作）。
`char[]`	`array()` 返回char数组，支持这个缓冲区（可选操作）。
`int`	`arrayOffset()` 返回在缓冲第一元这个缓冲区支持数组的偏移（可选操作）。
`abstract CharBuffer`	`asReadOnlyBuffer()` 创建一个共享此缓冲区内容的新的只读字符缓冲区缓冲区。
`char`	`charAt(int index)` 读取给定索引处相对于当前位置的字符。
`IntStream`	`chars()` 返回一个流 `int`零扩展 `char`值从这个序列。
`abstract CharBuffer`	`compact()` 契约这个缓冲区（可选操作）。
`int`	`compareTo(CharBuffer that)` 将此缓冲区与另一缓冲区。
`abstract CharBuffer`	`duplicate()` 创建一个共享此缓冲区内容的新的字符缓冲区。
`boolean`	`equals(Object ob)` 告诉是否这个缓冲区是否等于另一个对象。
`abstract char`	`get()` 相对得到方法。
`CharBuffer`	`get(char[] dst)` 相对体积得到方法。
`CharBuffer`	`get(char[] dst, int offset, int length)` 相对体积得到方法。
`abstract char`	`get(int index)` 绝对得到方法。
`boolean`	`hasArray()` 告诉是否这个缓冲区是由一个可访问的字符数组支持的。
`int`	`hashCode()` 返回此缓冲区的当前哈希代码。
`abstract boolean`	`isDirect()` 告诉是否这个字符缓冲区是直接的。
`int`	`length()` 返回此字符缓冲区的长度。
`abstract ByteOrder`	`order()` 检索此缓冲区的字节顺序。
`abstract CharBuffer`	`put(char c)` 相对放方法（可选操作）。
`CharBuffer`	`put(char[] src)` 相对体积放方法（可选操作）。
`CharBuffer`	`put(char[] src, int offset, int length)` 相对体积放方法（可选操作）。
`CharBuffer`	`put(CharBuffer src)` 相对体积放方法（可选操作）。
`abstract CharBuffer`	`put(int index, char c)` 绝对放方法（可选操作）。
`CharBuffer`	`put(String src)` 相对体积放方法（可选操作）。
`CharBuffer`	`put(String src, int start, int end)` 相对体积放方法（可选操作）。
`int`	`read(CharBuffer target)` 试图将字符读入指定的字符缓冲区中。
`abstract CharBuffer`	`slice()` 创建一个新字符串缓冲区的内容是一个共享的子缓冲区的内容。
`abstract CharBuffer`	`subSequence(int start, int end)` 创建一个新的字符缓冲区表示指定的子缓冲区，相对于当前位置。
`String`	`toString()` 返回包含此缓冲区中的字符的字符串。
`static CharBuffer`	`wrap(char[] array)` 将一个字符数组包到缓冲区中。
`static CharBuffer`	`wrap(char[] array, int offset, int length)` 将一个字符数组包到缓冲区中。
`static CharBuffer`	`wrap(CharSequence csq)` 将一个字符序列封装到一个缓冲区中。
`static CharBuffer`	`wrap(CharSequence csq, int start, int end)` 将一个字符序列封装到一个缓冲区中。

Methods inherited from class java.nio.Buffer
capacity, clear, flip, hasRemaining, isReadOnly, limit, limit, mark, position, position, remaining, reset, rewind

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.CharSequence
codePoints

- 方法详细信息
  - allocate
```
public static CharBuffer allocate(int capacity)
```
    分配一个新的字符缓冲区。
    新的缓冲区的位置将是零，它的限制将是它的容量，它的标记将是不确定的，它的每一个元素都将被初始化为零。这将有一个backing array，及其array offset将零。
    
    参数
    
    capacity -新的缓冲区的容量，在焦
    
    结果
    
    新的字符缓冲区
    
    异常
    
    IllegalArgumentException -如果 capacity是负整数
  - wrap
```
public static CharBuffer wrap(char[] array,
                              int offset,
                              int length)
```
    将一个字符数组包到缓冲区中。
    新的缓冲区将由给定的字符数组支持；也就是说，对缓冲区的修改将导致数组进行修改，反之亦然。新的缓冲区的容量将array.length，其位置将offset，极限将offset + length，其标志将是不确定的。其backing array将给定的数组，并将其array offset零。
    
    参数
    
    array的阵列，将新的缓冲区
    
    这阵用于抵消 offset -；必须是非负的且不大于 array.length。新的缓冲区的位置将被设置为这个值。
    
    length -要使用的子阵列的长度；必须是非负的且不大于 array.length - offset。新的缓冲区的限制将被设置为 offset + length。
    
    结果
    
    新的字符缓冲区
    
    异常
    
    IndexOutOfBoundsException -如果在 offset和 length参数的前提条件不成立
  - wrap
```
public static CharBuffer wrap(char[] array)
```
    将一个字符数组包到缓冲区中。
    新的缓冲区将由给定的字符数组支持；也就是说，对缓冲区的修改将导致数组进行修改，反之亦然。新的缓冲区的容量和限制将array.length，其位置将为零，其标志将是不确定的。其backing array将给定的数组，并将其array offset>零。
    
    参数
    
    array的阵列，将该缓冲区
    
    结果
    
    新的字符缓冲区
  - read
```
public int read(CharBuffer target)
         throws IOException
```
    试图将字符读入指定的字符缓冲区中。该缓冲区被用作一个字符库，是：唯一的变化是一个投入运行的结果。没有翻转或缓冲卷进行。
    
    Specified by:
    
    read 接口 Readable
    
    参数
    
    target -缓冲区中读取字符
    
    结果
    
    添加到缓冲区的字符数，或-如果此字符源的结束，则为1
    
    异常
    
    IOException如果I/O错误发生
    
    NullPointerException -如果目标是空的
    
    ReadOnlyBufferException -如果目标是一个只读缓冲区
    
    从以下版本开始：
    
    一点五
  - wrap
```
public static CharBuffer wrap(CharSequence csq,
                              int start,
                              int end)
```
    将一个字符序列封装到一个缓冲区中。
    新的，只读的缓冲区的内容将是给定的字符序列的内容。缓冲区的容量将csq.length()，其位置将start，极限将end，其标志将是不确定的。
    
    参数
    
    csq的字符序列，是要创建新的字符缓冲区
    
    start -第一个字符被用作索引；必须是非负的且不大于 csq.length()。新缓冲区的位置将被设置为这个值。
    
    end -使用的最后一个字符后的字符的索引；必须不小于不大于 csq.length() start。新的缓冲区的限制将被设置为这个值。
    
    结果
    
    新字符缓冲区
    
    异常
    
    IndexOutOfBoundsException -如果在 start和 end参数的前提条件不成立
  - wrap
```
public static CharBuffer wrap(CharSequence csq)
```
    将一个字符序列封装到一个缓冲区中。
    新的，只读的缓冲区的内容将是给定的字符序列的内容。新的缓冲区的容量和限制将csq.length()，其位置将为零，其标志将是不确定的。
    
    参数
    
    csq的字符序列，是要创建新的字符缓冲区
    
    结果
    
    新字符缓冲区
  - slice
```
public abstract CharBuffer slice()
```
    创建一个新字符串缓冲区的内容是一个共享的子缓冲区的内容。
    新的缓冲区的内容将从这个缓冲区的当前位置开始。这个缓冲区的内容的变化将在新的缓冲区中可见，反之亦然；两个缓冲区的位置，限制和标记值将是独立的。
    
    新缓冲区的位置将为零，其容量和限制将剩余在该缓冲区中的字符数，其标志将是不确定的。新的缓冲区将是直接的，如果，只有当这个缓冲区是直接的，它将是只读的，只有当，这个缓冲区是只读的。
    
    结果
    
    新的字符缓冲区
  - duplicate
```
public abstract CharBuffer duplicate()
```
    创建一个共享此缓冲区内容的新的字符缓冲区。
    新的缓冲区的内容将是这个缓冲区的内容。这个缓冲区的内容的变化将在新的缓冲区中可见，反之亦然；两个缓冲区的位置，限制和标记值将是独立的。
    
    新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。新的缓冲区将是直接的，如果，只有当这个缓冲区是直接的，它将是只读的，只有当，这个缓冲区是只读的。
    
    结果
    
    新的字符缓冲区
  - asReadOnlyBuffer
```
public abstract CharBuffer asReadOnlyBuffer()
```
    创建一个共享此缓冲区内容的新的只读字符缓冲区缓冲区。
    新的缓冲区的内容将是这个缓冲区的内容。对该缓冲区的内容的更改将在新的缓冲区中可见；但是，新的缓冲区本身将是只读的，不会允许共享内容被修改。这两个缓冲区的位置，限制，和标记值将是独立的。
    
    新的缓冲区的容量、限制、位置和标记值将与此缓冲区相同。
    
    如果这个缓冲区本身是只读那么这个方法的行为一样的duplicate方法。
    
    结果
    
    新的，只读的字符缓冲区
  - get
```
public abstract char get()
```
    相对得到方法。读取这个缓冲区的当前位置的字符，然后增量位置。
    
    结果
    
    缓冲区当前位置的字符
    
    异常
    
    BufferUnderflowException -如果缓冲区的当前位置不小于其极限
  - put
```
public abstract CharBuffer put(char c)
```
    相对放方法（可选操作）。
    将给定的字符字符写入当前位置的缓冲区中，然后将该位置增量。
    
    参数
    
    c的字符被写入
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果这个缓冲区的当前位置不小于其极限
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - get
```
public abstract char get(int index)
```
    绝对得到方法。读取给定索引中的字符。
    
    参数
    
    index -指数的字符将读
    
    结果
    
    给定索引中的字符
    
    异常
    
    IndexOutOfBoundsException -如果 index是负面或不小于缓冲区的限制
  - put
```
public abstract CharBuffer put(int index,
                               char c)
```
    绝对放方法（可选操作）。
    在给定的索引处将给定的字符写入该缓冲区中。
    
    参数
    
    index -索引的字符将被写入
    
    c -要写入的字符值
    
    结果
    
    这个缓冲区
    
    异常
    
    IndexOutOfBoundsException -如果 index是负面或不小于缓冲区的限制
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - get
```
public CharBuffer get(char[] dst,
                      int offset,
                      int length)
```
    相对体积得到方法。
    这种方法将字符从这个缓冲区到给定的目标数组。如果有更少的字符留在缓冲区比需要满足的要求，那就是，如果length > remaining()，然后没有字符转移和BufferUnderflowException抛出。
    
    否则，此方法复制length字符从这个缓冲区到给定的数组，从这个缓冲区的当前位置和在给定的数组中的偏移量。这个缓冲区的位置，再加length。
    
    换句话说，这种形式的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 -如果在 offset和 length参数的前提条件不成立
  - get
```
public CharBuffer get(char[] dst)
```
    相对体积得到方法。
    这种方法将字符从这个缓冲区到给定的目标数组。这种形式的src.get(a)方法调用的行为一样，调用
```
SRC。得到（一，0，a.length）
```
    参数
    
    dst -目标数组
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferUnderflowException -如果有少于 length焦留在这个缓冲区
  - put
```
public CharBuffer put(CharBuffer src)
```
    相对体积放方法（可选操作）。
    这种方法将字符留在了源缓冲区到缓冲区。如果有更多的字符保留在源缓冲区比这个缓冲区，即如果src.remaining() > remaining()，然后没有字符转移和BufferOverflowException抛出。
    
    否则，此方法复制N = src.remaining()字符从给定的缓冲区到缓冲区，开始在每个缓冲区的当前位置。这两个缓冲区的位置，然后加N.
    
    换句话说，这种形式的dst.put(src)方法调用作为循环具有完全相同的效果
```
而（SRC。hasremaining()）DST。把（SRC。get()）；
```
    除外，它首先检查这个缓冲区有足够的空间，这可能是更有效的。
    参数
    
    src -源缓冲区的字符被读取；不得这个缓冲区
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果没有足够的空间在这个缓冲区在源缓冲区剩余的字符
    
    IllegalArgumentException -如果源缓冲区缓冲区
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public CharBuffer put(char[] src,
                      int offset,
                      int length)
```
    相对体积放方法（可选操作）。
    这种方法将字符到缓冲区从给定的源阵列。如果有更多的字符被复制从阵列比保持在这个缓冲区，即如果length > remaining()，然后没有字符转移和BufferOverflowException抛出。
    
    否则，该方法length字符从给定的数组拷贝到缓冲区，从给定的数组中，该缓冲区的当前位置偏移。这个缓冲区的位置，再加length。
    
    换句话说，这种形式的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 -如果在 offset和 length参数的前提条件不成立
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public final CharBuffer put(char[] src)
```
    相对体积放方法（可选操作）。
    此方法将给定的源字符数组的整个内容转移到这个缓冲区中。这种形式的dst.put(a)方法调用的行为一样，调用
```
DST。把（一，0，a.length）
```
    参数
    
    src -源阵列
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果在这个缓冲区中没有足够的空间
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - put
```
public CharBuffer put(String src,
                      int start,
                      int end)
```
    相对体积放方法（可选操作）。
    这种方法将字符从字符串到缓冲区。如果有更多的字符被复制的字符串比保持在这个缓冲区，即如果end - start > remaining()，然后没有字符转移和BufferOverflowException抛出。
    
    否则，此方法复制N = end - start字符从字符串到缓冲区，从给定的start指数在这个缓冲区的当前位置。这个缓冲区的位置，再加
    
    换句话说，这种形式的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。把（s，0，美国length()）
```
    参数
    
    src -源字符串
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果在这个缓冲区中没有足够的空间
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - hasArray
```
public final boolean hasArray()
```
    告诉是否这个缓冲区是由一个可访问的字符数组支持的。
    如果此方法返回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()字符复制到指数为零，在指数P + 1字符复制到指数，等等，直到指数limit() - 1字符复制到指数n = limit() - 1 - P.缓冲区的位置，然后设置为n + 1的限制设置为它的能力。标记，如果定义，将被丢弃。
    
    缓冲区的位置设置为字符复制的数量，而不是零，所以，此方法的调用可以紧接着另一个相对放方法调用。
    
    结果
    
    这个缓冲区
    
    异常
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
  - isDirect
```
public abstract boolean isDirect()
```
    告诉是否这个字符缓冲区是直接的。
    
    Specified by:
    
    isDirect 方法重写，继承类 Buffer
    
    结果
    
    true如果，如果，这个缓冲区是直接
  - hashCode
```
public int hashCode()
```
    返回此缓冲区的当前哈希代码。
    一个字符串缓冲区的哈希代码仅取决于其剩余的元素；即，在从position()最多，元素，包括在limit() - 1元素。
    
    因为缓冲哈希码内容相关的，它是利用缓冲区作为哈希表或类似数据结构键不可取的除非它是已知的，他们的内容将不会被改变。
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    此缓冲区的当前哈希代码
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(Object ob)
```
    告诉是否这个缓冲区是否等于另一个对象。
    两个字符缓冲区是相等的，如果，只有，
    1. 他们有相同的元素类型，
    2. 他们有相同数量的剩余元素，和
    3. 两序列的其余元素，认为是独立的，他们的立场出发，逐点等。
    字符缓冲区不等于任何其他类型的对象。
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    ob -对象，这个缓冲区是比较
    
    结果
    
    true如果，如果，这等于给定对象的缓冲区
    
    另请参见：
    
    Object.hashCode()， HashMap
  - compareTo
```
public int compareTo(CharBuffer that)
```
    将此缓冲区与另一缓冲区。
    通过比较两字符缓冲区剩余的元素字典序列相比，不考虑每个序列的起始位置在其相应的缓冲区。对char元素对相比仿佛被调用Character.compare(char,char)。
    
    一个字符缓冲区不与任何其他类型的对象相媲美。
    
    Specified by:
    
    compareTo 接口 Comparable<CharBuffer>
    
    参数
    
    that要比较的对象。
    
    结果
    
    一个负整数，零，或一个正整数，因为这个缓冲区小于，等于或大于给定的缓冲区
  - 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的指标，相对于当前位置的字符在序列的最后一个字符之后；必须不小于不大于 remaining() start
    
    结果
    
    新字符缓冲区
    
    异常
    
    IndexOutOfBoundsException如果 start和 end前提不成立
  - append
```
public CharBuffer append(CharSequence csq)
```
    将指定的字符序列，这个缓冲区（可选操作）。
    这种形式的dst.append(csq)方法调用的行为一样，调用
```
DST。把（CSQ。tostring()）
```
    根据字符序列的csq toString规范，整个序列可能不追加。例如，调用字符缓冲区的toString方法将返回一个序列的内容取决于缓冲区的位置和范围。
    Specified by:
    
    append 接口 Appendable
    
    参数
    
    csq -字符序列添加。如果 csq是 null，然后四个字 "null"附加到这个字符缓冲区。
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果在这个缓冲区中没有足够的空间
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
    
    从以下版本开始：
    
    一点五
  - append
```
public CharBuffer append(CharSequence csq,
                         int start,
                         int end)
```
    添加一个序列指定的字符序列，这个缓冲区（可选操作）。
    这种形式的dst.append(csq, start, end)方法调用时，csq不null，表现在完全相同的方式调用
```
DST。把（CSQ。子序列（开始、结束）。tostring()）
```
    Specified by:
    
    append 接口 Appendable
    
    参数
    
    csq -字符序列的子序列将追加。如果 csq是 null，那么人物将追加好像 csq包含四个字符 "null"。
    
    start -子序列中的第一个字符的索引
    
    end -子序列中的最后一个字符后的字符的索引
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果在这个缓冲区中没有足够的空间
    
    IndexOutOfBoundsException -如果 start或 end是负面的， start大于 end，或 end大于 csq.length()
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
    
    从以下版本开始：
    
    一点五
  - append
```
public CharBuffer append(char c)
```
    将指定的字符缓冲区（可选操作）。
    这种形式的dst.append(c)方法调用的行为一样，调用
```
DST将（C）。
```
    Specified by:
    
    append 接口 Appendable
    
    参数
    
    c - 16位字符追加
    
    结果
    
    这个缓冲区
    
    异常
    
    BufferOverflowException -如果在这个缓冲区中没有足够的空间
    
    ReadOnlyBufferException -如果这个缓冲区是只读的
    
    从以下版本开始：
    
    一点五
  - order
```
public abstract ByteOrder order()
```
    检索此缓冲区的字节顺序。
    一个用现有的char阵列底层硬件的native order分配或创建的字符串缓冲区的字节顺序。字节顺序的字符串缓冲区的创建了一个view一字节缓冲区是字节缓冲区目前创建视图。
    
    结果
    
    此缓冲区的字节顺序
  - chars
```
public IntStream chars()
```
    从接口复制的描述： CharSequence
    
    返回一个流 int零扩展 char值从这个序列。任何字符映射到一个 surrogate code point通过解释。
    如果在读取流时序列发生突变，则结果是未定义的。
    
    Specified by:
    
    chars 接口 CharSequence
    
    结果
    
    从这个序列的字符值的intstream

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class CharBuffer

方法摘要

Methods inherited from class java.nio.Buffer

Methods inherited from class java.lang.Object

Methods inherited from interface 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

toString

length

charAt

subSequence

append

append

append

order

chars