JDK源码阅读第二天——java.lang.CharSequence

接口

CharSequence

1.概述

public interface CharSequence
CharSequence是一个可读的字符值序列。这个接口提供了对许多不同类型的char序列的统一的只读访问。char值表示基本的多语言平面(BMP)或代理的字符。有关详细信息，请参阅Unicode字符表示。
此接口没有完善 equals 和 hashCode 方法的常规协定。因此，通常未定义比较实现 CharSequence 的两个对象的结果。每个对象都可以通过一个不同的类实现，而且不能保证每个类能够测试其实例与其他类的实例的相等性。因此，使用任意 CharSequence 实例作为集合中的元素或映射中的键是不合适的。

2. 已知实现子接口和实现类

子接口：javax.lang.model.element.Name
实现类：CharBuffer, Segment, String, StringBuffer, StringBuilder

3. 源码阅读

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 {

    /**
     * 返回此字符序列的长度。该长度是序列中的 16 位 char 数.
     * @return  此序列中的 char 数

     */
    int length();

    /**
     *
     * 返回指定索引处的char值。
     * @param   index   要返回的 char 值的索引
     *
     * @return  指定的Char值
     *
     * @throws  IndexOutOfBoundsException
     *          如果 index 参数为负或不小于 length()

     */
    char charAt(int index);

    /**
     * 返回一个新的 CharSequence，它是此序列的子序列。子序列从指定序列的 char 值开始，并
     * 在索引 end - 1 的 char 值结束。返回序列的长度（char 中）是 end - start，因此，
     * 如果 start == end，则返回一个空序列。
     *
     * @param   start   开始索引（包括）
     * @param   end     结束索引（不包括）
     *
     * @return  指定的子序列
     *
     * @throws  IndexOutOfBoundsException
     *          如果 start 或 end 为负，end 大于 length() 或者 start 大于 end
     */
    CharSequence subSequence(int start, int end);

    /**
     * 返回一个包含此序列中字符的字符串，该字符串与此序列的顺序相同。
     * 字符串的长度就是此序列的长度。
     * 覆盖： 类 Object 中的 toString
     * @return 一个完全由此序列的字符组成的字符串
     */
    public String toString();

    /**
     * 返回一个从这个序列中值为零扩展的字符值的流。
     * 映射到代理代码点的任何字符都将通过未解释的方式传递。
     * 如果在读取流时发生了突变，则结果是未定义的。
     *
     * @return 从这个序列的IntStream字符值
     * @since 1.8
     */
    public default IntStream chars() {
        class CharIterator implements PrimitiveIterator.OfInt {
            int cur = 0;
        //如果迭代器中还有元素，则返回true。
            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));
                }
            }
        }
// 返回一个通过继承了Spliterator.OfInt的Supplier 创建的新的顺序或并行IntStream 。
        return StreamSupport.intStream(() ->
                Spliterators.spliterator(
                        new CharIterator(),
                        length(),
                        Spliterator.ORDERED),
                Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
                false);
    }

    /**
     * 从这个序列返回一个代码点值流。在序列中遇到的任何代理对都是按字符组合的。
     * toCodePoint和结果被传递到流。任何其他代码单元，
     * 包括普通的BMP字符、未配对的代理和未定义的代码单元，都是零扩展到int值，
     * 然后将这些值传递给流。 如果在读取流时发生了突变，则结果是未定义的。
     *
     * @return 从这个序列中输入的Unicode代码点。
     * @since 1.8
     */
    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;
                }
            }
        //如果迭代器中还有元素，则返回true。
            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;
            }
        }
// 返回一个通过继承了Spliterator.OfInt的Supplier 创建的新的顺序或并行IntStream 。
        return StreamSupport.intStream(() ->
                Spliterators.spliteratorUnknownSize(
                        new CodePointIterator(),
                        Spliterator.ORDERED),
                Spliterator.ORDERED,
                false);
    }
}