概述

字符序列接口，封装了对字符序列的一些操作（包括转换为流的操作）
java.lang.CharSequence接口是一个可读的字符序列。此接口为不同类型的字符序列提供了一种统一且只读的访问方式。如String、StringBuilder、CharArray等都实现了该接口。
CharSequence接口没refine Object类中定义的equals和hashCode方法的通用约定，因此对于两个实现了该接口的对象而言，在进行对比是，通常其结果也是未定义的。同时，使用任意的CharSequence实例作为set集合的元素或者map中的key是不合适的，因为实现该接口的每个对象可以由不同的类来实现，导致无法保证每个类都有和其他类实例有等价的测试能力。

length()方法

返回字符序列的长度。由于String类采用的是UTF-16编码，因此该方法返回的值肯定是16bit的整数倍。

int length();

charAt(int)方法

返回索引index处的字符。

char charAt(int index);

subSequence(int, int)方法

返回该字符序列的子序列。子序列包含原序列的第start个位置的字符，但不含第end个位置的字符。另外，如果入参start==end，则返回空序列。

CharSequence subSequence(int start, int end);

toString()方法

返回由这个字符序列组成的字符串

String toString();

compare()方法

按字典顺序比较两个字符序列，不重要

    static int compare(CharSequence cs1, CharSequence cs2) {
        // 两个字符序列不为空且相等的场合
        if(Objects.requireNonNull(cs1) == Objects.requireNonNull(cs2)) {
            return 0;
        }
        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();
    }

chars()方法

将当前char序列转为流序列，序列中每个元素是char

    default IntStream chars() {
        // 元素类型是int类型(包括byte,short,char)的Iterator
        class CharIterator implements PrimitiveIterator.OfInt {
            int cur = 0;
            public boolean hasNext() {
                return cur<length();
            }
            public int nextInt() {
                // 元素有的场合
                if(hasNext()) {
                    // 返回索引index处的字符
                    return charAt(cur++);
                } else {
                    throw new NoSuchElementException();
                }
            }
            @Override
            public void forEachRemaining(IntConsumer block) {
                // 遍历所有元素
                for(; cur<length(); cur++) {
                    // 将所有元素以char类型消费掉，后面就无法调用
                    block.accept(charAt(cur));
                }
            }
        }
        // 返回用于创建和操作流
        return StreamSupport.intStream(
            () -> Spliterators.spliterator(new CharIterator(), length(), Spliterator.ORDERED),
            Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
            false
        );
    }

codePoints()方法

将当前Unicode符号序列转为流序列，序列中每个元素是Unicode符号

    default IntStream codePoints() {
        class CodePointIterator implements PrimitiveIterator.OfInt {
            int cur = 0;
            public boolean hasNext() {
                return cur<length();
            }
            public int nextInt() {
                final int length = length();
                if(cur >= length) {
                    throw new NoSuchElementException();
                }
                char c1 = charAt(cur++);
                // Unicode高代理区的场合
                if(Character.isHighSurrogate(c1) && cur<length) {
                    char c2 = charAt(cur);
                    // Unicode低代理区的场合
                    if(Character.isLowSurrogate(c2)) {
                        cur++;
                        // 返回值是Unicode符号编码值
                        return Character.toCodePoint(c1, c2);
                    }
                }
                return c1;
            }
            @Override
            public void forEachRemaining(IntConsumer block) {
                final int length = length();
                int i = cur;
                try {
                    while(i<length) {
                        char c1 = charAt(i++);
                        // Unicode高代理区的场合
                        if(!Character.isHighSurrogate(c1) || i >= length) {
                            block.accept(c1);
                        } else {
                            char c2 = charAt(i);
                            // Unicode低代理区的场合
                            if(Character.isLowSurrogate(c2)) {
                                i++;
                                block.accept(Character.toCodePoint(c1, c2));
                            } else {
                                block.accept(c1);
                            }
                        }
                    }
                } finally {
                    cur = i;
                }
            }
        }
        return StreamSupport.intStream(
            () -> Spliterators.spliteratorUnknownSize(new CodePointIterator(), Spliterator.ORDERED),
            Spliterator.ORDERED,
            false
        );
    }