源码解析---CharSequence

/**
 * CharSequence是 char 值的可读序列。此接口提供对许多不同类型的 char 序列的统一，只读访问。
 * char 值表示 Basic 多语言平面（BMP）中的字符或代理项。
 * 此接口没有实现equals和 hashCode（）方法。因此，比较实现CharSequence 的两个对象的结果通常是不可控的。
 * 每个对象可以由不同的类实现，并且不能保证每个类能够测试其实例与另一个实例的相等性。
 * 因此，使用任意 CharSequence 实例作为集合中的元素或映射中的键是不合适的
 */

public interface CharSequence {

    /**
     *返回字符序列的长度
     */
    int length();

    /**
     *返回指定位置的字符，0<=index<=length-1
     */
    char charAt(int index);

    /**
     *返回[start,end)位置的字符序列，长度为end - start，如果start == end，则返回空的字符
     *
     */
    CharSequence subSequence(int start, int end);

    /**
     *和Object的toString()方法一样
     */
    public String toString();

    /**
     *Java8中的新特性，之后会介绍
     */
    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);
    }

    /**
     *Java8中的新特性，之后会介绍
     */
    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);
    }
}