public final class String
implements java.io.Serializable, Comparable, CharSequence,
Constable, ConstantDesc
String实现了5个接口,Serializable和Comparable比较好理解,后面三个比较难理解
CharSequence
字节序列,提供只读的,统一的访问自己序列方法。
int length();
char charAt(int index);
CharSequence subSequence(int start, int end);
public String toString();
这些方法的作用都比较好理解。
接口中还提供了几个默认方法
1.public default IntStream chars()
java8添加,返回Int流。之所以是Int类型是因为java字符串采用的编码格式是utf-16或Latin,单个字符可能最大时32位
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);
}
其中有一个内部类,实现PrimitiveIterator.OfInt ,Int迭代器。
forEachRemaining的意思是对剩下的未迭代的元素继续迭代,不同于forEach每次调用重新迭代,所有元素只会迭代一次。
public static Spliterator.OfInt spliterator(PrimitiveIterator.OfInt iterator,
long size,
int characteristics)
Int分割器,第一个参数Int迭代器,第二次参数是长度,第三个参数是迭代特性。
public static final int ORDERED = 0x00000010;//表示元素是有序的
public static final int DISTINCT = 0x00000001;//表示元素不重复
public static final int SORTED = 0x00000004;//表示元素是按一定规律进行排列(有指定比较器)
public static final int SIZED = 0x00000040;//是否确定大小
public static final int NONNULL = 0x00000100;//表示迭代器中没有null元素
public static final int IMMUTABLE = 0x00000400;//表示元素不可变
public static final int CONCURRENT = 0x00001000;//表示迭代器可以多线程操作
[参考]https://blog.csdn.net/m0_37664906/article/details/80360388
public default IntStream codePoints()
获取code point流
由于uft-16由一个或两个16位的码组成,code point实际是区分及定位字符的点。比如一个16*4位数据,是4个字节?3个或者2个?内部通过比较等逻辑区分后输出
public static int compare(CharSequence cs1, CharSequence cs2)
静态比较方法
public static int compare(CharSequence cs1, CharSequence cs2) {
// 判断地址是否相等
if (Objects.requireNonNull(cs1) == Objects.requireNonNull(cs2)) {
return 0;
}
// 是否类型相同,并调用compareTo方法
if (cs1.getClass() == cs2.getClass() && cs1 instanceof Comparable) {
return ((Comparable
Constable, ConstantDesc
Constable代表这个类型是可以房子常量池中的
ConstantDesc 代表常量的描述信息,猜测类似于类的信息或者索引信息等
String,Integer,Long,Float,Double的常量描述就是自身,其他类型由自己的实现
coder COMPACT_STRINGS
java9之后,为了节省字符串的空间,默认开启字符串压缩,也就是用byte(8位)保存字母。COMPACT_STRINGS默认开启。coder由两个值:LATIN1,UTF16。UTF16是肯定没有开启压缩的。
具体参考:https://www.jianshu.com/p/8a9b2c60e569
String(char[] value, int off, int len, Void sig) {
if (len == 0) {
this.value = "".value;
this.coder = "".coder;
return;
}
if (COMPACT_STRINGS) {
byte[] val = StringUTF16.compress(value, off, len);
if (val != null) {
this.value = val;
this.coder = LATIN1;
return;
}
}
this.coder = UTF16;
this.value = StringUTF16.toBytes(value, off, len);
}
先判断是否开启压缩,如果开启则先通过UTF16压缩成byte,如果成功则修改coder为LATIN1,否则关闭压缩,coder为UTF16.
length
public int length() {
return value.length >> coder();
}
@Native static final byte LATIN1 = 0;
@Native static final byte UTF16 = 1;
16位的utf16是LATIN的2倍,所以直接右移1位。
但是UTF16是变长的,所以类似于emoji的字符串计算的时候会感觉会出现问题。这个是怎么解决的?
压缩字符串
String中的各种操作都需要判断coder,再采用不同的处理方法。
如果两个字符串的编码格式相同,处理比较容易。如果不同,则需要先转换成UTF16,再处理,多了一步转换的过程,可能会影响性能。例
public String concat(String str) {
if (str.isEmpty()) {
return this;
}
if (coder() == str.coder()) {
byte[] val = this.value;
byte[] oval = str.value;
int len = val.length + oval.length;
byte[] buf = Arrays.copyOf(val, len);
System.arraycopy(oval, 0, buf, val.length, oval.length);
return new String(buf, coder);
}
int len = length();
int olen = str.length();
byte[] buf = StringUTF16.newBytesFor(len + olen);
getBytes(buf, 0, UTF16);
str.getBytes(buf, len, UTF16);
return new String(buf, UTF16);
}
多了一步StringUTF16.newBytesFor(len + olen)的过程。