测试高亮代码

Posted 2021-03-20 houzheng

public interface CharSequence {

        /**
         * 长度
         */
        int length();

        /**
         * 根据索引返回char值
         */
        char charAt(int index);

        /**
         * 根据索引区间,求子序列
         */
        java.lang.CharSequence subSequence(int start, int end);

        public String toString();

        /**
         * 1.8新增方法,返回一个 int的流，从这个序列中零扩展 char值
         */
        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) {//接受一个consumer函数
                    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);
        }

        /**
         * 从此序列返回码流值
         */
        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);
        }

        /**
         *
         */
        @SuppressWarnings("unchecked")
        public static int compare(java.lang.CharSequence cs1, java.lang.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();
        }
    }