java.nio
類別 CharBuffer

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

所有已實作的介面：

Appendable, CharSequence, Comparable<CharBuffer>, Readable

public abstract class CharBuffer
extends Buffer
implements Comparable<CharBuffer>, Appendable, CharSequence, Readable

字元緩衝區。

此類別定義了字元緩衝區上的四類別操作：

• 讀寫單個字元的絕對和相對 get 和 put 方法；

• 將此緩衝區中的連續字元序列傳輸到陣列中的相對批量 get 方法；

• 將字元陣列、字元串或其他字元緩衝區中的連續字元序列傳輸到此緩衝區的相對批量 put 方法；以及

• 字元緩衝區的 compacting、duplicating 和 slicing 方法。

字元緩衝區可以通過 allocation 方法創建，此方法通過 wrapping 將一個現有字元陣列或字元串包裹到緩衝區中來為緩衝區內容分派空間，或者通過創建現有位元組緩衝區的視圖來創建。

像位元組緩衝區一樣，字元緩衝區要麼是直接的，要麼是非直接的。通過此類別的 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);

從以下版本開始：

1.4

方法摘要

static CharBuffer	allocate(int capacity) 分派新的字元緩衝區。
CharBuffer	append(char c) 將指定字元添加到此緩衝區（可選操作）。
CharBuffer	append(CharSequence csq) 將指定的字元序列添加到此緩衝區（可選操作）。
CharBuffer	append(CharSequence csq, int start, int end) 將指定字元序列的子序列添加到此緩衝區（可選操作）。
char[]	array() 返回實作此緩衝區的字元陣列（可選操作）。
int	arrayOffset() 返回此緩衝區中的第一個元素在緩衝區的底層實作陣列中的偏移量（可選操作）。
abstract CharBuffer	asReadOnlyBuffer() 創建共享此緩衝區內容的新的只讀字元緩衝區。
char	charAt(int index) 讀取相對於當前位置的給定索引處的字元。
abstract CharBuffer	compact() 壓縮此緩衝區（可選操作）。
int	compareTo(CharBuffer that) 將此緩衝區與另一個緩衝區進行比較。
abstract CharBuffer	duplicate() 創建共享此緩衝區內容的新的字元緩衝區。
boolean	equals(Object ob) 判斷此緩衝區是否與另一個物件相同。
abstract char	get() 相對 get 方法。
CharBuffer	get(char[] dst) 相對批量 get 方法。
CharBuffer	get(char[] dst, int offset, int length) 相對批量 get 方法。
abstract char	get(int index) 絕對 get 方法。
boolean	hasArray() 判斷該緩衝區是否可通過一個可存取的字元陣列實作。
int	hashCode() 返回此緩衝區的當前雜湊碼。
abstract boolean	isDirect() 判斷此字元緩衝區是否為直接的。
int	length() 返回此字元緩衝區的長度。
abstract ByteOrder	order() 獲取此緩衝區的位元組順序。
abstract CharBuffer	put(char c) 相對 put 方法（可選操作）。
CharBuffer	put(char[] src) 相對批量 put 方法（可選操作）。
CharBuffer	put(char[] src, int offset, int length) 相對批量 put 方法（可選操作）。
CharBuffer	put(CharBuffer src) 相對批量 put 方法（可選操作）。
abstract CharBuffer	put(int index, char c) 絕對 put 方法（可選操作）。
CharBuffer	put(String src) 相對批量 put 方法（可選操作）。
CharBuffer	put(String src, int start, int end) 相對批量 put 方法（可選操作）。
int	read(CharBuffer target) 試圖將字元讀入指定的字元緩衝區。
abstract CharBuffer	slice() 創建新的字元緩衝區，其內容為此緩衝區內容的共享子序列。
abstract CharSequence	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) 將字元序列包裹到緩衝區中。

從類別 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

方法詳細資訊

allocate

public static CharBuffer allocate(int capacity)

分派新的字元緩衝區。

新緩衝區的位置將為零，其界限將為其容量，其標記是未定義的。它將具有一個底層實作陣列，且其陣列偏移量將為零。

參數：

capacity - 新緩衝區的容量，以字元為單位

返回：

新的字元緩衝區

拋出：

IllegalArgumentException - 如果 capacity 為負整數

wrap

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

將字元陣列包裹到緩衝區中。

給定的字元陣列將支持新緩衝區；即緩衝區修改將導致陣列修改，反之亦然。新緩衝區的容量將為 array.length，其位置將為 offset，其界限將為 offset + length，其標記是未定義的。其底層實作陣列將為給定陣列，並且其陣列偏移量將為零。

參數：

array - 支持新緩衝區的陣列

offset - 要使用的子陣列的偏移量；必須為非負且不大於 array.length。將新緩衝區的位置設置為此值。

length - 要使用的子陣列的長度；必須為非負且不大於 array.length - offset。新緩衝區的界限將被設置為 offset + length。

返回：

新的字元緩衝區

拋出：

IndexOutOfBoundsException - 如果關於 offset 和 length 參數的前提不成立

wrap

public static CharBuffer wrap(char[] array)

將字元陣列包裹到緩衝區中。

給定的字元陣列將支持新緩衝區；即緩衝區修改將導致陣列修改，反之亦然。新緩衝區的容量和界限將為 array.length，其位置將為零，其標記是未定義的。其底層實作陣列將為給定陣列，並且其陣列偏移量將為零。

參數：

array - 實作此緩衝區的陣列

返回：

新的字元緩衝區

read

public int read(CharBuffer target)
         throws IOException

試圖將字元讀入指定的字元緩衝區。緩衝區可照原樣用作字元的存儲資源庫：所做的唯一更改是 put 操作的結果。不對緩衝區執行翻轉或重繞操作。

指定者：

介面 Readable 中的 read

參數：

target - 要將字元讀入的緩衝區

返回：

添加到緩衝區的字元數量，如果此字元源位於緩衝區末端，則返回 -1

拋出：

IOException - 如果發生 I/O 錯誤

NullPointerException - 如果目標為空

ReadOnlyBufferException - 如果目標是一個只讀緩衝區

從以下版本開始：

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 - 如果關於 offset 和 length 參數的前提不成立

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()

相對 get 方法。讀取此緩衝區當前位置的字元，然後該位置遞增。

返回：

緩衝區當前位置的字元

拋出：

BufferUnderflowException - 如果緩衝區當前位置不小於其界限

put

public abstract CharBuffer put(char c)

相對 put 方法（可選操作）。

將給定字元寫入此緩衝區的當前位置，然後該位置遞增。

參數：

c - 要寫入的字元

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區的當前位置不小於界限

ReadOnlyBufferException - 如果此緩衝區是只讀的

get

public abstract char get(int index)

絕對 get 方法。讀取給定索引處的字元。

參數：

index - 將讀取字元的位置的索引

返回：

給定索引處的字元

拋出：

IndexOutOfBoundsException - 如果 index 為負或不小於緩衝區界限

put

public abstract CharBuffer put(int index,
                               char c)

絕對 put 方法（可選操作）。

將給定字元寫入此緩衝區的給定索引處。

參數：

index - 將在該位置寫入字元

c - 要寫入的字元值

返回：

此緩衝區

拋出：

IndexOutOfBoundsException - 如果 index 為負或不小於緩衝區界限

ReadOnlyBufferException - 如果此緩衝區是只讀的

get

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

相對批量 get 方法。

此方法將此緩衝區中的字元傳輸到給定的目標陣列中。如果緩衝區中剩餘的字元少於滿足請求所需的字元，即如果 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)

相對批量 get 方法。

此方法將此緩衝區的字元傳輸到給定的目標陣列中。調用此方法的形式為 src.get(a)，該調用與以下調用完全相同：

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

返回：

此緩衝區

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘字元少於 length

put

public CharBuffer put(CharBuffer 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 CharBuffer put(char[] src,
                      int offset,
                      int length)

相對批量 put 方法（可選操作）。

此方法將給定源陣列中的字元傳輸到此緩衝區中。如果要從陣列複製的字元多於此緩衝區中的剩餘字元空間，即如果 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)

相對批量 put 方法（可選操作）。

此方法將給定源字元陣列的所有內容傳輸到此緩衝區中。調用此方法的形式為 dst.put(a)，該調用與以下調用完全相同：

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

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區沒有足夠空間

ReadOnlyBufferException - 如果此緩衝區是只讀的

put

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

相對批量 put 方法（可選操作）。

此方法將給定字元串中的字元傳輸到此緩衝區中。如果要從字元串複製的字元多於此緩衝區中的剩餘字元空間，即如果 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)); 

區別在於它首先檢查此緩衝區中是否有足夠空間，這樣可能效率更高。

參數：

src - 要從中讀取字元的字元串

start - 要讀取的第一個字元在字元串中的偏移量；必須為非負且不大於 string.length()

end - 要讀取的最後一個字元在字元串中的偏移量加上 1；必須為非負且不大於 string.length()

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區沒有足夠空間

IndexOutOfBoundsException - 如果關於 start 和 end 參數的前提不成立

ReadOnlyBufferException - 如果此緩衝區是只讀的

put

public final CharBuffer put(String src)

相對批量 put 方法（可選操作）。

此方法將給定源字元串中的所有內容傳輸到此緩衝區中。調用此方法的形式為 dst.put(s)，該調用與以下調用完全相同：

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

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區沒有足夠空間

ReadOnlyBufferException - 如果此緩衝區是只讀的

hasArray

public final boolean hasArray()

判斷該緩衝區是否可通過一個可存取的字元陣列實作。

如果此方法返回 true，則可以安全地調用 array 和 arrayOffset 方法。

指定者：

類別 Buffer 中的 hasArray

返回：

當且僅當存在實作此緩衝區的陣列，並且此緩衝區不是只讀緩衝區時，返回 true

array

public final char[] array()

返回實作此緩衝區的字元陣列（可選操作）。

此緩衝區的內容修改將導致返回的陣列內容修改，反之亦然。

調用此方法之前要調用 hasArray 方法，以確保此緩衝區具有可存取的底層實作陣列。

指定者：

類別 Buffer 中的 array

返回：

實作此緩衝區的陣列

拋出：

ReadOnlyBufferException - 如果存在實作此緩衝區的陣列，但緩衝區是只讀的

UnsupportedOperationException - 如果不存在某個可存取的陣列實作此緩衝區

arrayOffset

public final int arrayOffset()

返回此緩衝區中的第一個元素在緩衝區的底層實作陣列中的偏移量（可選操作）。

如果存在實作此緩衝區的陣列，則緩衝區位置 p 對應於陣列索引 p + arrayOffset()。

調用此方法之前要調用 hasArray 方法，以確保此緩衝區具有可存取的底層實作陣列。

指定者：

類別 Buffer 中的 arrayOffset

返回：

此緩衝區的第一個元素在緩衝區陣列中的偏移量

拋出：

ReadOnlyBufferException - 如果存在實作此緩衝區的陣列，但緩衝區是只讀的

UnsupportedOperationException - 如果不存在某個可存取的陣列實作此緩衝區

compact

public abstract CharBuffer compact()

壓縮此緩衝區（可選操作）。

將緩衝區當前位置和界限之間的字元（如果有）複製到緩衝區的開始處。即將索引 p = position() 處的字元複製到索引 0 處，將索引 p + 1 處的字元複製到索引 1 處，依此類別推，直到將索引 limit() - 1 處的字元複製到索引 n = limit() - 1 - p 處。然後將緩衝區的位置設置為 n+1，並將其界限設置為其容量。如果已定義了標記，則丟棄它。

將緩衝區的位置設置為複製的字元數，而不是零，以便調用此方法後可以緊接著調用另一個相對 put 方法。

返回：

此緩衝區

拋出：

ReadOnlyBufferException - 如果此緩衝區是只讀的

isDirect

public abstract boolean isDirect()

判斷此字元緩衝區是否為直接的。

指定者：

類別 Buffer 中的 isDirect

返回：

當且僅當此緩衝區為直接時，返回 true

hashCode

public int hashCode()

返回此緩衝區的當前雜湊碼。

字元緩衝區的雜湊碼只取決於其剩餘元素；即取決於從 position() 開始一直到（包括） limit() - 1 處的元素。

因為緩衝區雜湊碼與內容有關，因此建議不要在雜湊映射或其他類似資料結構中將緩衝區用作鍵，除非知道其內容不會發生更改。

覆寫：

類別 Object 中的 hashCode

返回：

此緩衝區的當前雜湊碼

另請參見：

Object.equals(java.lang.Object), Hashtable

equals

public boolean equals(Object ob)

判斷此緩衝區是否與另一個物件相同。

兩個字元緩衝區是相同的，當且僅當：

1. 它們具有相同的元素型別，

2. 它們具有相同數量的剩餘元素，並且

3. 兩個剩餘元素序列（與它們的起始位置無關）逐點相同。

字元緩衝區與任何其他型別的物件都不同。

覆寫：

類別 Object 中的 equals

參數：

ob - 此緩衝區要比較的物件

返回：

當且僅當此緩衝區與給定物件相同時，返回 true

另請參見：

Object.hashCode(), Hashtable

compareTo

public int compareTo(CharBuffer that)

將此緩衝區與另一個緩衝區進行比較。

比較兩個字元緩衝區的方法是按字典順序比較它們的剩餘元素序列，而不考慮每個序列在其對應緩衝區中的起始位置。

字元緩衝區不能與任何其他型別的物件進行比較。

指定者：

介面 Comparable<CharBuffer> 中的 compareTo

參數：

that - 要比較的物件。

返回：

如果此緩衝區小於、等於或大於給定緩衝區，則相應返回負整數、零或正整數

toString

public String toString()

返回包含此緩衝區中字元的字元串。

所得字元串的第一個字元將為此緩衝區位置處的字元，最後一個字元將為索引 limit() - 1 處的字元。調用此方法不更改緩衝區的位置。

指定者：

介面 CharSequence 中的 toString

覆寫：

類別 Object 中的 toString

返回：

指定的字元串

length

public final int length()

返回此字元緩衝區的長度。

當將字元緩衝區視為字元序列時，長度只是該位置（包括）和界限（不包括）之間的字元數；即長度等效於 remaining()。

指定者：

介面 CharSequence 中的 length

返回：

此字元緩衝區的長度

charAt

public final char charAt(int index)

讀取相對於當前位置的給定索引處的字元。

指定者：

介面 CharSequence 中的 charAt

參數：

index - 要讀取的相對於該位置的字元的索引；必須為非負且小於 remaining()

返回：

索引 position() + index 處的字元

拋出：

IndexOutOfBoundsException - 如果關於 index 的前提不成立

subSequence

public abstract CharSequence subSequence(int start,
                                         int end)

創建表示此緩衝區的指定序列、相對於當前位置的新字元緩衝區。

新緩衝區將共享此緩衝區的內容；即如果此緩衝區的內容是可變的，則修改一個緩衝區將導致另一個緩衝區被修改。新緩衝區的容量將為此緩衝區的容量，其位置將為 position() + start，其界限將為 position() + end。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

指定者：

介面 CharSequence 中的 subSequence

參數：

start - 子序列中第一個字元相對於當前位置的索引；必須為非負且不大於 remaining()

end - 子序列中最後一個字元後面的字元相對於當前位置的索引；必須不小於 start 且不大於 remaining()

返回：

新的字元序列

拋出：

IndexOutOfBoundsException - 如果關於 start 和 end 的前提不成立

append

public CharBuffer append(CharSequence csq)

將指定的字元序列添加到此緩衝區（可選操作）。

調用此方法的形式為 dst.append(csq)，該調用與以下調用完全相同：

     dst.put(csq.toString()) 

可能沒有添加整個序列，這取決於針對字元序列 csq 的 toString 規範。例如，調用字元緩衝區的 toString 方法將返回一個子序列，其內容取決於緩衝區的位置和界限。

指定者：

介面 Appendable 中的 append

參數：

csq - 要添加的字元序列。如果 csq 為 null，則向此字元緩衝區添加四個字元 "null"。

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區沒有足夠空間

ReadOnlyBufferException - 如果此緩衝區是只讀的

從以下版本開始：

1.5

append

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

將指定字元序列的子序列添加到此緩衝區（可選操作）。

當 csq 不為 null 時，調用此方法的形式為 dst.append(csq, start, end)，該調用與以下調用完全相同：

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

指定者：

介面 Appendable 中的 append

參數：

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)

將指定字元添加到此緩衝區（可選操作）。

調用此方法的形式為 dst.append(c)，該調用與以下調用完全相同：

     dst.put(c) 

指定者：

介面 Appendable 中的 append

參數：

c - 要添加的 16 位字元

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區沒有足夠空間

ReadOnlyBufferException - 如果此緩衝區是只讀的

從以下版本開始：

1.5

order

public abstract ByteOrder order()

獲取此緩衝區的位元組順序。

通過分派或通過包裹現有 char 陣列而創建的字元緩衝區的位元組順序是底層硬體的 native order。作為位元組緩衝區的視圖而創建的字元緩衝區的位元組順序是創建視圖時位元組緩衝區的位元組順序。

返回：

此緩衝區的位元組順序