JDK源码阅读笔记--String

public final class String
    implements java.io.Serializable, Comparable<String>, 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<Object>) cs1).compareTo(cs2);
        }
        // 以最短的序列为基准，一个个比较
        for (int i = 0, len = Math.min(cs1.length(), cs2.length()); i < len; i++) {
            char a = cs1.charAt(i);
            char b = cs2.charAt(i);
            if (a != b) {
                return a - b;
            }
        }

       // 直接比较长度
        return cs1.length() - cs2.length();
    }

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)的过程。