java.nio
public
abstract
class
java.nio.CharBuffer
A buffer of char
s.
A char buffer can be created in either of the following ways:
- Allocate a new char array and create a buffer
based on it;
- Wrap an existing char array to create a new
buffer;
- Wrap an existing char sequence to create a
new buffer;
- Use ByteBuffer.asCharBuffer
to create a char buffer based on a byte buffer.
Summary
Public Methods
|
|
|
static |
|
CharBuffer |
allocate(int capacity) |
|
|
|
|
|
CharBuffer |
append(char c) |
|
|
|
|
|
CharBuffer |
append(CharSequence csq) |
|
|
|
|
|
CharBuffer |
append(CharSequence csq, int start, int end) |
|
|
final |
|
|
char[] |
array() |
|
|
final |
|
|
int |
arrayOffset() |
abstract |
|
|
|
|
CharBuffer |
asReadOnlyBuffer() |
|
|
final |
|
|
char |
charAt(int index) |
abstract |
|
|
|
|
CharBuffer |
compact() |
|
|
|
|
|
int |
compareTo(CharBuffer otherBuffer) |
abstract |
|
|
|
|
CharBuffer |
duplicate() |
|
|
|
|
|
boolean |
equals(Object other) |
abstract |
|
|
|
|
char |
get() |
|
|
|
|
|
CharBuffer |
get(char[] dest) |
abstract |
|
|
|
|
char |
get(int index) |
|
|
|
|
|
CharBuffer |
get(char[] dest, int off, int len) |
|
|
final |
|
|
boolean |
hasArray() |
|
|
|
|
|
int |
hashCode() |
abstract |
|
|
|
|
boolean |
isDirect() |
|
|
final |
|
|
int |
length() |
abstract |
|
|
|
|
ByteOrder |
order() |
|
|
|
|
|
CharBuffer |
put(char[] src, int off, int len) |
abstract |
|
|
|
|
CharBuffer |
put(int index, char c) |
abstract |
|
|
|
|
CharBuffer |
put(char c) |
|
|
|
|
|
CharBuffer |
put(CharBuffer src) |
|
|
final |
|
|
CharBuffer |
put(char[] src) |
|
|
final |
|
|
CharBuffer |
put(String str) |
|
|
|
|
|
CharBuffer |
put(String str, int start, int end) |
|
|
|
|
|
int |
read(CharBuffer target) |
abstract |
|
|
|
|
CharBuffer |
slice() |
abstract |
|
|
|
|
CharSequence |
subSequence(int start, int end) |
|
|
|
|
|
String |
toString() |
|
|
|
static |
|
CharBuffer |
wrap(char[] array, int start, int len) |
|
|
|
static |
|
CharBuffer |
wrap(CharSequence chseq) |
|
|
|
static |
|
CharBuffer |
wrap(char[] array) |
|
|
|
static |
|
CharBuffer |
wrap(CharSequence chseq, int start, int end) |
capacity,
clear,
flip,
hasRemaining,
isReadOnly,
limit,
limit,
mark,
position,
position,
remaining,
reset,
rewind
clone,
equals,
finalize,
getClass,
hashCode,
notify,
notifyAll,
toString,
wait,
wait,
wait
Details
Public Methods
public
static
CharBuffer
allocate(int capacity)
Creates a char buffer based on a new allocated char array.
Parameters
capacity
| The capacity of the new buffer |
public
CharBuffer
append(char c)
Append the given character.
Append the given
CharSequence
.
The behaviour of this method depends on the implementation class of
Appendable
.
If the give CharSequence
is null, the sequence is treated as
String "null".
Append part of the given
CharSequence
.
If the given CharSequence
is not null, this method behaves
same as the following statement:
out.append(csq.subSequence(start, end))
If the give CharSequence
is null, the sequence is treated as
String "null".
public
final
char[]
array()
Returns the char array which this buffer is based on, if there's one.
Returns
- The char array which this buffer is based on
public
final
int
arrayOffset()
Returns the offset of the char array which this buffer is based on, if
there's one.
The offset is the index of the array corresponds to the zero position of
the buffer.
Returns
- The offset of the char array which this buffer is based on
public
abstract
CharBuffer
asReadOnlyBuffer()
Returns a readonly buffer that shares content with this buffer.
The returned buffer is guaranteed to be a new instance, even this buffer
is readonly itself. The new buffer's position, limit, capacity and mark
are the same as this buffer.
The new buffer shares content with this buffer, which means this buffer's
change of content will be visible to the new buffer. The two buffer's
position, limit and mark are independent.
Returns
- A readonly version of this buffer.
public
final
char
charAt(int index)
Returns the character located at the specified index in the buffer. The
index value is referenced from the current buffer position.
Parameters
index
| The index referenced from the current buffer position. It must
not be less than zero but less than the value obtained from a
call to remaining() |
Returns
- the character located at the specified index (referenced from the
current position) in the buffer.
public
abstract
CharBuffer
compact()
Compacts this char buffer.
The remaining char
s will be moved to the head of the
buffer, staring from position zero. Then the position is set to
remaining()
; the limit is set to capacity; the mark is
cleared.
public
int
compareTo(CharBuffer otherBuffer)
Compare the remaining
char
s of this buffer to another
char buffer's remaining
char
s.
Parameters
otherBuffer
| Another char buffer |
Returns
- a negative value if this is less than
other
; 0 if
this equals to other
; a positive value if this is
greater than other
public
abstract
CharBuffer
duplicate()
Returns a duplicated buffer that shares content with this buffer.
The duplicated buffer's position, limit, capacity and mark are the same
as this buffer. The duplicated buffer's readonly property and byte order
are same as this buffer too.
The new buffer shares content with this buffer, which means either
buffer's change of content will be visible to the other. The two buffer's
position, limit and mark are independent.
Returns
- A duplicated buffer that shares content with this buffer.
public
boolean
equals(Object other)
Tests whether this char buffer equals to another object.
If other
is not a char buffer, then false is returned.
Two char buffers are equals if, and only if, their remaining
char
s are exactly the same. Position, limit, capacity and
mark are not considered.
Parameters
other
| the object to be compared against |
Returns
- Whether this char buffer equals to another object.
public
abstract
char
get()
Returns the char at the current position and increase the position by 1.
Returns
- The char at the current position.
public
CharBuffer
get(char[] dest)
Reads
char
s from the current position into the specified
char array and increase the position by the number of
char
s
read.
Calling this method has the same effect as
get(dest, 0, dest.length)
.
Parameters
dest
| The destination char array |
public
abstract
char
get(int index)
Returns a char at the specified index, and the position is not changed.
Parameters
index
| The index, must be no less than zero and less than limit |
Returns
- A char at the specified index.
public
CharBuffer
get(char[] dest, int off, int len)
Reads
char
s from the current position into the specified
char array, starting from the specified offset, and increase the position
by the number of
char
s read.
Parameters
dest
| The target char array |
off
| The offset of the char array, must be no less than zero and no
greater than dest.length |
len
| The number of char s to read, must be no less
than zero and no greater than dest.length - off |
public
final
boolean
hasArray()
Returns whether this buffer is based on a char array and is read/write.
If this buffer is readonly, then false is returned.
Returns
- Whether this buffer is based on a char array and is read/write.
public
int
hashCode()
Hash code is calculated from the remaining
char
s.
Position, limit, capacity and mark don't affect the hash code.
Returns
- The hash code calculated from the remaining
char
s.
public
abstract
boolean
isDirect()
Returns true if this buffer is direct.
A direct buffer will try its best to take advantage of native memory APIs
and it may not stay in java heap, thus not affected by GC.
A char buffer is direct, if it is based on a byte buffer and the byte
buffer is direct.
Returns
- True if this buffer is direct.
public
final
int
length()
Returns the number of remaining
char
s.
Returns
- The number of remaining
char
s.
public
abstract
ByteOrder
order()
Returns the byte order used by this buffer when converting
char
s from/to
byte
s.
If this buffer is not based on a byte buffer, then always return the
platform's native byte order.
Returns
- The byte order used by this buffer when converting
char
s from/to byte
s.
public
CharBuffer
put(char[] src, int off, int len)
Writes
char
s in the given char array, starting from the
specified offset, to the current position and increase the position by
the number of
char
s written.
Parameters
src
| The source char array |
off
| The offset of char array, must be no less than zero and no
greater than src.length |
len
| The number of char s to write, must be no less
than zero and no greater than src.length - off |
public
abstract
CharBuffer
put(int index, char c)
Write a char to the specified index of this buffer and the position is
not changed.
Parameters
index
| The index, must be no less than zero and less than the limit |
c
| The char to write |
public
abstract
CharBuffer
put(char c)
Writes the given char to the current position and increase the position
by 1.
Writes all the remaining
char
s of the
src
char buffer to this buffer's current position, and increase both buffers'
position by the number of
char
s copied.
Parameters
src
| The source char buffer |
public
final
CharBuffer
put(char[] src)
Writes
char
s in the given char array to the current
position and increase the position by the number of
char
s
written.
Calling this method has the same effect as
put(src, 0, src.length)
.
Parameters
src
| The source char array |
Write all
char
s of the give string to the current
position of this buffer, and increase the position by the length of
string.
Calling this method has the same effect as
put(str, 0, str.length())
.
public
CharBuffer
put(String str, int start, int end)
Write
char
s of the given string to the current position
of this buffer, and increase the position by the number of
char
s written.
Parameters
str
| The string to write |
start
| The first char to write, must be no less than zero and no
greater than str.length() |
end
| The last char to write (excluding), must be less than
start and no greater than
str.length() |
public
int
read(CharBuffer target)
Reads the characters into the given
CharBuffer
. The
maximum number of characters read is
CharBuffer.remaining()
.
public
abstract
CharBuffer
slice()
Returns a sliced buffer that shares content with this buffer.
The sliced buffer's capacity will be this buffer's
remaining()
, and its zero position will correspond to
this buffer's current position. The new buffer's position will be 0,
limit will be its capacity, and its mark is unset. The new buffer's
readonly property and byte order are same as this buffer.
The new buffer shares content with this buffer, which means either
buffer's change of content will be visible to the other. The two buffer's
position, limit and mark are independent.
Returns
- A sliced buffer that shares content with this buffer.
public
abstract
CharSequence
subSequence(int start, int end)
Returns a new char buffer represents a sub-sequence of this buffer's
current remaining content.
The new buffer's position will be position() + start
,
limit will be position() + end
, capacity will be same as
this buffer. The new buffer's readonly property and byte order are same
as this buffer.
The new buffer shares content with this buffer, which means either
buffer's change of content will be visible to the other. The two buffer's
position, limit and mark are independent.
Parameters
start
| The start index of the sub-sequence, referenced from the
current buffer position. Must not be less than zero and not
greater than the value obtained from a call to
remaining() . |
end
| The end index of the sub-sequence, referenced from the current
buffer position. Must not be less than start
and not be greater than the value obtained from a call to
remaining() |
Returns
- A new char buffer represents a sub-sequence of this buffer's
current remaining content.
public
String
toString()
Returns a string represents the current remaining
char
s
of this buffer.
Returns
- A string represents the current remaining
char
s
of this buffer.
public
static
CharBuffer
wrap(char[] array, int start, int len)
Creates new a char buffer by wrapping the given char array.
The new buffer's position will be start
, limit will be
start + len
, capacity will be the length of the array.
Parameters
array
| The char array which the new buffer will be based on |
start
| The start index, must be no less than zero and no greater than
array.length |
len
| The length, must be no less than zero and no greater than
array.length - start |
Creates a new char buffer by wrapping the given char sequence.
Calling this method has the same effect as
wrap(chseq, 0, chseq.length())
.
Parameters
chseq
| The char sequence which the new buffer will be based on |
public
static
CharBuffer
wrap(char[] array)
Creates a new char buffer by wrapping the given char array.
Calling this method has the same effect as
wrap(array, 0, array.length)
.
Parameters
array
| The char array which the new buffer will be based on |
public
static
CharBuffer
wrap(CharSequence chseq, int start, int end)
Creates a new char buffer by wrapping the given char sequence.
The new buffer's position will be start
, limit will be
end
, capacity will be the length of the char sequence.
The new buffer is readonly.
Parameters
chseq
| The char sequence which the new buffer will be based on |
start
| The start index, must be no less than zero and no greater than
chseq.length() |
end
| The end index, must be no less than start and
no greater than chseq.length() |