深入学习java源码之CharBuffer.append()与CharBuffer.slice()
使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变
我们知道数组是引用变量类型，当final修饰引用变量的时候，变量中保存的地址是不能更改的，但是指针指向的数组本身是可以更改的,final修饰并不能限制数组本身的改变
final
修饰类 final修饰类时，说明该类你不想被别人继承！一个类不被别的类继承就可以使用final来修饰
注意 final类中的所有成员方法都会被隐式地指定为final方法。
修饰方法 当一个方法被final修饰后，就代表该方法无法被重写，如果你想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的
同时注意 如果父类的 final修饰的方法设置为private，则子类可以写一个同名的方法，此时 ，该同名的方法不再产生final的报错，而是在子类重新定义了一个方法（注：类的private方法会隐式地被指定为final方法。）
修饰变量
被final修饰的变量其实就相当于定义了一个常量，无法被修改的变量，如果final修饰的是一个基本数据类型的变量，那么这个变量的值就定了，不能变了，而如果修饰的是一个引用变量，那么该变量存的是一个内存地址，该地址就不能变了，但是该内存地址所指向的那个对象还是可以变的，就像你记住了人家的门牌号，但你不能管人家家里人员数量
但是你可以改那个对象的内容！
还有的人给方法定义的参数是 final类型的，是不想别人在方法内部修改参数的值，如果final修饰的是一个基本类型，那么是可以的，如果修饰的是引用类型，那么便不行了，因为就如上文那个str.append 对象的内容是可以变化的！
readable接口
Readable接口就是为了Scanner类专门创建的一个接口，使得Scanner的入口参数不必限于某个类。实现Readable接口要只需是实现public int read(CharBuffer cb)方法。当方法返回-1时候Scanner类停止读取。
import java.io.IOException;
import java.nio.CharBuffer;
import java.util.Random;
import java.util.Scanner;
public class RandomWords implements Readable{
private Random rand=new Random(47);
private static final char[] capitals="ABCDEFGHIJKLMOPQRSTUVWXYZ".toCharArray();
private static final char[] lowers="ABCDEFGHIJKLMOPQRSTUVWXYZ".toLowerCase().toCharArray();
private static final char[] vowels="aeiou".toCharArray();
private int count;
public RandomWords(int count) {
this.count=count;
}
@Override
public int read(CharBuffer cb) throws IOException {
if (count--==0) {
return -1;
}
cb.append(capitals[rand.nextInt(capitals.length)]);
for (int i = 0; i < 4; i++) {
cb.append(vowels[rand.nextInt(vowels.length)]);
cb.append(lowers[rand.nextInt(lowers.length)]);
}
cb.append(" ");
return 10;
}
public static void main(String[] args) {
Scanner scanner=new Scanner(new RandomWords(10));
while (scanner.hasNext()) {
System.out.println(scanner.next());
}
}
}
java源码
Modifier and TypeMethod and Descriptionstatic CharBufferallocate(int capacity) 分配一个新的char缓冲区。
CharBufferappend(char c) 将指定的字符追加到此缓冲区 （可选操作） 。
CharBufferappend(CharSequence csq) 将指定的字符序列追加到此缓冲区 （可选操作） 。
CharBufferappend(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此缓冲区 （可选操作） 。
char[]array() 返回支持此缓冲区的char数组 （可选操作） 。
intarrayOffset() 返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量 （可选操作） 。
abstract CharBufferasReadOnlyBuffer() 创建一个新的只读char缓冲区，共享此缓冲区的内容。
charcharAt(int index) 以相对于当前位置的给定索引读取字符。
IntStreamchars() 返回 int的流，从该序列零扩展 char值。
abstract CharBuffercompact() 压缩此缓冲区 （可选操作） 。
intcompareTo(CharBuffer that) 将此缓冲区与另一个缓冲区进行比较。
abstract CharBufferduplicate() 创建一个新的char缓冲区，共享此缓冲区的内容。
booleanequals(Object ob) 告诉这个缓冲区是否等于另一个对象。
abstract charget() 相对 获取方法。
CharBufferget(char[] dst) 相对批量 获取方法。
CharBufferget(char[] dst, int offset, int length) 相对批量 获取方法。
abstract charget(int index) 绝对 获取方法。
booleanhasArray() 告诉这个缓冲区是否由可访问的字符数组支持。
inthashCode() 返回此缓冲区的当前哈希码。
abstract booleanisDirect() 告诉这个char缓冲区是否直接。
intlength() 返回此字符缓冲区的长度。
abstract ByteOrderorder() 检索此缓冲区的字节顺序。
abstract CharBufferput(char c) 相对 放置法 （可选操作） 。
CharBufferput(char[] src) 相对大容量 put方法 （可选操作） 。
CharBufferput(char[] src, int offset, int length) 相对大容量 put方法 （可选操作） 。
CharBufferput(CharBuffer src) 相对大容量 put方法 （可选操作） 。
abstract CharBufferput(int index, char c) 绝对 put方法 （可选操作） 。
CharBufferput(String src) 相对大容量 put方法 （可选操作） 。
CharBufferput(String src, int start, int end) 相对大容量 put方法 （可选操作） 。
intread(CharBuffer target) 尝试将字符读入指定的字符缓冲区。
abstract CharBufferslice() 创建一个新的char缓冲区，其内容是此缓冲区内容的共享子序列。
abstract CharBuffersubSequence(int start, int end) 创建一个新的字符缓冲区，代表该缓冲区相对于当前位置的指定子序列。
StringtoString() 返回一个包含此缓冲区中字符的字符串。
static CharBufferwrap(char[] array) 将一个char数组包装到缓冲区中。
static CharBufferwrap(char[] array, int offset, int length) 将一个char数组包装到缓冲区中。
static CharBufferwrap(CharSequence csq) 将字符序列包装到缓冲区中。
static CharBufferwrap(CharSequence csq, int start, int end) 将字符序列包装到缓冲区中。
package java.nio;
import java.io.IOException;
import java.util.Spliterator;
import java.util.stream.StreamSupport;
import java.util.stream.IntStream;
public abstract class CharBuffer
extends Buffer
implements Comparable, Appendable, CharSequence, Readable
{
// These fields are declared here rather than in Heap-X-Buffer in order to
// reduce the number of virtual method invocations needed to access these
// values, which is especially costly when coding small buffers.
//
final char[] hb; // Non-null only for heap buffers
final int offset;
boolean isReadOnly; // Valid only for heap buffers
// Creates a new buffer with the given mark, position, limit, capacity,
// backing array, and array offset
//
CharBuffer(int mark, int pos, int lim, int cap, // package-private
char[] hb, int offset)
{
super(mark, pos, lim, cap);
this.hb = hb;
this.offset = offset;
}
// Creates a new buffer with the given mark, position, limit, and capacity
//
CharBuffer(int mark, int pos, int lim, int cap) { // package-private
this(mark, pos, lim, cap, null, 0);
}
public static CharBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapCharBuffer(capacity, capacity);
}
public static CharBuffer wrap(char[] array,
int offset, int length)
{
try {
return new HeapCharBuffer(array, offset, length);
} catch (IllegalArgumentException x) {
throw new IndexOutOfBoundsException();
}
}
public static CharBuffer wrap(char[] array) {
return wrap(array, 0, array.length);
}
public int read(CharBuffer target) throws IOException {
// Determine the number of bytes n that can be transferred
int targetRemaining = target.remaining();
int remaining = remaining();
if (remaining == 0)
return -1;
int n = Math.min(remaining, targetRemaining);
int limit = limit();
// Set source limit to prevent target overflow
if (targetRemaining < remaining)
limit(position() + n);
try {
if (n > 0)
target.put(this);
} finally {
limit(limit); // restore real limit
}
return n;
}
public static CharBuffer wrap(CharSequence csq, int start, int end) {
try {
return new StringCharBuffer(csq, start, end);
} catch (IllegalArgumentException x) {
throw new IndexOutOfBoundsException();
}
}
public static CharBuffer wrap(CharSequence csq) {
return wrap(csq, 0, csq.length());
}
public abstract CharBuffer slice();
public abstract CharBuffer duplicate();
public abstract CharBuffer asReadOnlyBuffer();
// -- Singleton get/put methods --
public abstract char get();
public abstract CharBuffer put(char c);
public abstract char get(int index);
abstract char getUnchecked(int index); // package-private
public abstract CharBuffer put(int index, char c);
// -- Bulk get operations --
public CharBuffer get(char[] dst, int offset, int length) {
checkBounds(offset, length, dst.length);
if (length > remaining())
throw new BufferUnderflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
dst[i] = get();
return this;
}
public CharBuffer get(char[] dst) {
return get(dst, 0, dst.length);
}
// -- Bulk put operations --
public CharBuffer put(CharBuffer src) {
if (src == this)
throw new IllegalArgumentException();
if (isReadOnly())
throw new ReadOnlyBufferException();
int n = src.remaining();
if (n > remaining())
throw new BufferOverflowException();
for (int i = 0; i < n; i++)
put(src.get());
return this;
}
public CharBuffer put(char[] src, int offset, int length) {
checkBounds(offset, length, src.length);
if (length > remaining())
throw new BufferOverflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
this.put(src[i]);
return this;
}
public final CharBuffer put(char[] src) {
return put(src, 0, src.length);
}
public CharBuffer put(String src, int start, int end) {
checkBounds(start, end - start, src.length());
if (isReadOnly())
throw new ReadOnlyBufferException();
if (end - start > remaining())
throw new BufferOverflowException();
for (int i = start; i < end; i++)
this.put(src.charAt(i));
return this;
}
public final CharBuffer put(String src) {
return put(src, 0, src.length());
}
// -- Other stuff --
public final boolean hasArray() {
return (hb != null) && !isReadOnly;
}
public final char[] array() {
if (hb == null)
throw new UnsupportedOperationException();
if (isReadOnly)
throw new ReadOnlyBufferException();
return hb;
}
public final int arrayOffset() {
if (hb == null)
throw new UnsupportedOperationException();
if (isReadOnly)
throw new ReadOnlyBufferException();
return offset;
}
public abstract CharBuffer compact();
public abstract boolean isDirect();
public int hashCode() {
int h = 1;
int p = position();
for (int i = limit() - 1; i >= p; i--)
h = 31 * h + (int)get(i);
return h;
}
public boolean equals(Object ob) {
if (this == ob)
return true;
if (!(ob instanceof CharBuffer))
return false;
CharBuffer that = (CharBuffer)ob;
if (this.remaining() != that.remaining())
return false;
int p = this.position();
for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--)
if (!equals(this.get(i), that.get(j)))
return false;
return true;
}
private static boolean equals(char x, char y) {
return x == y;
}
public int compareTo(CharBuffer that) {
int n = this.position() + Math.min(this.remaining(), that.remaining());
for (int i = this.position(), j = that.position(); i < n; i++, j++) {
int cmp = compare(this.get(i), that.get(j));
if (cmp != 0)
return cmp;
}
return this.remaining() - that.remaining();
}
private static int compare(char x, char y) {
return Character.compare(x, y);
}
// -- Other char stuff --
public String toString() {
return toString(position(), limit());
}
abstract String toString(int start, int end); // package-private
// --- Methods to support CharSequence ---
public final int length() {
return remaining();
}
public final char charAt(int index) {
return get(position() + checkIndex(index, 1));
}
public abstract CharBuffer subSequence(int start, int end);
public CharBuffer append(CharSequence csq) {
if (csq == null)
return put("null");
else
return put(csq.toString());
}
public CharBuffer append(CharSequence csq, int start, int end) {
CharSequence cs = (csq == null ? "null" : csq);
return put(cs.subSequence(start, end).toString());
}
public CharBuffer append(char c) {
return put(c);
}
public abstract ByteOrder order();
@Override
public IntStream chars() {
return StreamSupport.intStream(() -> new CharBufferSpliterator(this),
Buffer.SPLITERATOR_CHARACTERISTICS, false);
}
}
@Override
public IntStream chars() {
return StreamSupport.intStream(() -> new CharBufferSpliterator(this),
Buffer.SPLITERATOR_CHARACTERISTICS, false);
}
}
Modifier and TypeMethod and Description
abstract Objectarray() 返回支持此缓冲区的数组 （可选操作） 。
abstract intarrayOffset() 返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量 （可选操作） 。
intcapacity() 返回此缓冲区的容量。
Bufferclear() 清除此缓冲区。
Bufferflip() 翻转这个缓冲区。
abstract booleanhasArray() 告诉这个缓冲区是否由可访问的数组支持。
booleanhasRemaining() 告诉当前位置和极限之间是否存在任何元素。
abstract booleanisDirect() 告诉这个缓冲区是否为 direct 。
abstract booleanisReadOnly() 告知这个缓冲区是否是只读的。
intlimit() 返回此缓冲区的限制。
Bufferlimit(int newLimit) 设置此缓冲区的限制。
Buffermark() 将此缓冲区的标记设置在其位置。
intposition() 返回此缓冲区的位置。
Bufferposition(int newPosition) 设置这个缓冲区的位置。
intremaining() 返回当前位置和限制之间的元素数。
Bufferreset() 将此缓冲区的位置重置为先前标记的位置。
Bufferrewind() 倒带这个缓冲区。
package java.nio;
import java.util.Spliterator;
public abstract class Buffer {
static final int SPLITERATOR_CHARACTERISTICS =
Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;
// Invariants: mark limit) || (newPosition < 0))
throw new IllegalArgumentException();
position = newPosition;
if (mark > position) mark = -1;
return this;
}
public final int limit() {
return limit;
}
public final Buffer limit(int newLimit) {
if ((newLimit > capacity) || (newLimit < 0))
throw new IllegalArgumentException();
limit = newLimit;
if (position > limit) position = limit;
if (mark > limit) mark = -1;
return this;
}
public final Buffer mark() {
mark = position;
return this;
}
public final Buffer reset() {
int m = mark;
if (m < 0)
throw new InvalidMarkException();
position = m;
return this;
}
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}
public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}
public final Buffer rewind() {
position = 0;
mark = -1;
return this;
}
public final int remaining() {
return limit - position;
}
public final boolean hasRemaining() {
return position < limit;
}
public abstract boolean isReadOnly();
public abstract boolean hasArray();
public abstract Object array();
public abstract int arrayOffset();
public abstract boolean isDirect();
// -- Package-private methods for bounds checking, etc. --
final int nextGetIndex() { // package-private
if (position >= limit)
throw new BufferUnderflowException();
return position++;
}
final int nextGetIndex(int nb) { // package-private
if (limit - position < nb)
throw new BufferUnderflowException();
int p = position;
position += nb;
return p;
}
final int nextPutIndex() { // package-private
if (position >= limit)
throw new BufferOverflowException();
return position++;
}
final int nextPutIndex(int nb) { // package-private
if (limit - position < nb)
throw new BufferOverflowException();
int p = position;
position += nb;
return p;
}
final int checkIndex(int i) { // package-private
if ((i < 0) || (i >= limit))
throw new IndexOutOfBoundsException();
return i;
}
final int checkIndex(int i, int nb) { // package-private
if ((i < 0) || (nb > limit - i))
throw new IndexOutOfBoundsException();
return i;
}
final int markValue() { // package-private
return mark;
}
final void truncate() { // package-private
mark = -1;
position = 0;
limit = 0;
capacity = 0;
}
final void discardMark() { // package-private
mark = -1;
}
static void checkBounds(int off, int len, int size) { // package-private
if ((off | len | (off + len) | (size - (off + len))) < 0)
throw new IndexOutOfBoundsException();
}
}
Modifier and TypeMethod and Description
charcharAt(int index) 返回 char指定索引处的值。
default IntStreamchars() 返回一个 int的流，从这个序列中零扩展 char值。
default IntStreamcodePoints() 从此序列返回码流值。
intlength() 返回此字符序列的长度。
CharSequencesubSequence(int start, int end) 返回一个 CharSequence ，这是这个序列的一个子序列。
StringtoString() 以与此顺序相同的顺序返回包含此序列中的字符的字符串。
package java.lang;
import java.util.NoSuchElementException;
import java.util.PrimitiveIterator;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
public interface CharSequence {
int length();
char charAt(int index);
CharSequence subSequence(int start, int end);
public String toString();
public default IntStream chars() {
class CharIterator implements PrimitiveIterator.OfInt {
int cur = 0;
public boolean hasNext() {
return cur < length();
}
public int nextInt() {
if (hasNext()) {
return charAt(cur++);
} else {
throw new NoSuchElementException();
}
}
@Override
public void forEachRemaining(IntConsumer block) {
for (; cur < length(); cur++) {
block.accept(charAt(cur));
}
}
}
return StreamSupport.intStream(() ->
Spliterators.spliterator(
new CharIterator(),
length(),
Spliterator.ORDERED),
Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
false);
}
public default IntStream codePoints() {
class CodePointIterator implements PrimitiveIterator.OfInt {
int cur = 0;
@Override
public void forEachRemaining(IntConsumer block) {
final int length = length();
int i = cur;
try {
while (i < length) {
char c1 = charAt(i++);
if (!Character.isHighSurrogate(c1) || i >= length) {
block.accept(c1);
} else {
char c2 = charAt(i);
if (Character.isLowSurrogate(c2)) {
i++;
block.accept(Character.toCodePoint(c1, c2));
} else {
block.accept(c1);
}
}
}
} finally {
cur = i;
}
}
public boolean hasNext() {
return cur < length();
}
public int nextInt() {
final int length = length();
if (cur >= length) {
throw new NoSuchElementException();
}
char c1 = charAt(cur++);
if (Character.isHighSurrogate(c1) && cur < length) {
char c2 = charAt(cur);
if (Character.isLowSurrogate(c2)) {
cur++;
return Character.toCodePoint(c1, c2);
}
}
return c1;
}
}
return StreamSupport.intStream(() ->
Spliterators.spliteratorUnknownSize(
new CodePointIterator(),
Spliterator.ORDERED),
Spliterator.ORDERED,
false);
}
}
package java.lang;
import java.util.*;
public interface Comparable {
public int compareTo(T o);
}package java.lang;
import java.io.IOException;
public interface Readable {
public int read(java.nio.CharBuffer cb) throws IOException;
}
