java接口CharSequence源码分析

目录

简介

前面4个方法

后面两个方法

---

简介

字符序列，被String，StringBuilder，StringBuffer继承。

/**
 * 
一个CharSequence是一个可读的char值的序列。
 * 这个接口为许多不同种类的char序列提供统一的，只读的访问。
 * 一个char值代表了BMP的一个字符或者一个代理。
 * 有关详细信息，请参阅Unicode字符表示。
 * 
 * 
这个接口没有细化equals和hashcode方法的通用约定。
 * 因此，比较两个实现CharSequence类的对象的结果，通常，没有被定义。
 * 每个对象可以被不同的类实现，不能保证每个类能测试它的实例与其他类的实例是否相等。
 * 因此，将任何CharSequence的实例用作set的元素或者map的key是不合适的。
 *
 * @author Mike McCloskey
 * @since 1.4
 * @spec JSR-51
 */

public interface CharSequence

前面4个方法

    /**
     * 返回这个字符序列的长度。长度是序列中16bit的char的数量。
     *
     * @return  the number of chars in this sequence
     */
    int length();

    /**
     * 
返回特定索引的char的值。索引范围为0到length()-1.
     * 序列中第一个char在索引0，下一个是1，以此类推。
     * 
     * 
如果特定索引上的char值是由unicode代理的，就会返回代理的值。
     *
     * @param   index   the index of the char value to be returned
     *
     * @return  the specified char value
     *
     * @throws  IndexOutOfBoundsException   如果所有参数是负的或者不小于length()
     */
    char charAt(int index);

    /**
     * 返回一个是这个序列的子序列的CharSequence。
     * 这个子序列以索引为start的字符开始，以索引为end-1的字符结束。
     * 返回的CharSequence的长度是end - start，
     * 所以如果start == end，返回的子序列是空的
     *
     * @param   start   the start index, inclusive
     * @param   end     the end index, exclusive
     *
     * @return  the specified subsequence
     *
     * @throws  IndexOutOfBoundsException   如果start或者end是负的，或者end比length()大，或者start比end大
     */
    CharSequence subSequence(int start, int end);

    /**
     * 返回一个包含这个序列中的字符，而且字符顺序相同的字符串。
     * 字符串的长度与这个序列的长度相同。
     *
     * @return  a string consisting of exactly this sequence of characters
     */
    public String toString();

后面两个方法

这两个方法暂时没看，以后需要再研究

    /**
     * Returns a stream of {@code int} zero-extending the {@code char} values
     * from this sequence.  Any char which maps to a surrogate code
     * point is passed through uninterpreted.
     *
     * 
If the sequence is mutated while the stream is being read, the
     * result is undefined.
     *
     * @return an IntStream of char values from this sequence
     * @since 1.8
     */
    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);
    }

    /**
     * Returns a stream of code point values from this sequence.  Any surrogate
     * pairs encountered in the sequence are combined as if by {@linkplain
     * Character#toCodePoint Character.toCodePoint} and the result is passed
     * to the stream. Any other code units, including ordinary BMP characters,
     * unpaired surrogates, and undefined code units, are zero-extended to
     * {@code int} values which are then passed to the stream.
     *
     * 
If the sequence is mutated while the stream is being read, the result
     * is undefined.
     *
     * @return an IntStream of Unicode code points from this sequence
     * @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;
                }
            }

            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);
    }