java中charsequence_java.lang.CharSequence

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;/**

* CharSequence是一个可读的char序列.这个接口提供许多不同字符序列的统一,只读的方法.

* 一个char值是Basic Multilingual Plane (BMP)中一个.具体参考

* Unicode Character 表示

*

*

*

这个接口并不违反 {@link java.lang.Object#equals(java.lang.Object) equals} 和

* {@link java.lang.Object#hashCode() hashCode} 的约定.

* 因此比较俩个CharSequence序列的结果通常是没有定义.

* 不同的对象由不同的类实现,因此不保证测试它们实例能够被测试是否相等.

* 所以,不推荐在set或者map的key中使用CharSequence

**/

/**

* A CharSequence is a readable sequence of char values. This

* interface provides uniform, read-only access to many different kinds of

* char sequences.

* A char value represents a character in the Basic

* Multilingual Plane (BMP) or a surrogate. Refer to

* href="Character.html#unicode">Unicode Character Representation

for details.

*

*

This interface does not refine the general contracts of the {@link

* java.lang.Object#equals(java.lang.Object) equals} and {@link

* java.lang.Object#hashCode() hashCode} methods. The result of comparing two

* objects that implement CharSequence is therefore, in general,

* undefined. Each object may be implemented by a different class, and there

* is no guarantee that each class will be capable of testing its instances

* for equality with those of the other. It is therefore inappropriate to use

* arbitrary CharSequence instances as elements in a set or as keys in

* a map.

*

* @author Mike McCloskey

* @since 1.4

* @spec JSR-51*/

public interfaceCharSequence {/**

* 返回字符序列的长度,16-bit位char的个数.*/

/**

* Returns the length of this character sequence. The length is the number

* of 16-bit chars in the sequence.

*

* @return the number of chars in this sequence*/

intlength();/**

* Returns the char value at the specified index. An index ranges from zero

* to length() - 1. The first char value of the sequence is at

* index zero, the next at index one, and so on, as for array

* indexing.

*

*

If the char value specified by the index is a

* surrogate, the surrogate

* value is returned.

*

* @param index the index of the char value to be returned

*

* @return the specified char value

*

* @throws IndexOutOfBoundsException

* if the index argument is negative or not less than

* length()*/

char charAt(intindex);/**

* Returns a CharSequence that is a subsequence of this sequence.

* The subsequence starts with the char value at the specified index and

* ends with the char value at index end - 1. The length

* (in chars) of the

* returned sequence is end - start, so if start == end

* then an empty sequence is returned.

*

* @param start the start index, inclusive

* @param end the end index, exclusive

*

* @return the specified subsequence

*

* @throws IndexOutOfBoundsException

* if start or end are negative,

* if end is greater than length(),

* or if start is greater than end*/CharSequence subSequence(int start, intend);/**

* Returns a string containing the characters in this sequence in the same

* order as this sequence. The length of the string will be the length of

* this sequence.

*

* @return a string consisting of exactly this sequence of characters*/

publicString toString();/**

* Returns a stream of {@code int} zero-extending the {@code char} values

* from this sequence. Any char which maps to a

* href="{@docRoot}/java/lang/Character.html#unicode">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 defaultIntStream chars() {classCharIterator implements PrimitiveIterator.OfInt {int cur = 0;publicboolean hasNext() {return cur

}public intnextInt() {if(hasNext()) {return charAt(cur++);

}else{throw newNoSuchElementException();

}

}

@Overridepublic voidforEachRemaining(IntConsumer block) {for (; cur < length(); cur++) {

block.accept(charAt(cur));

}

}

}return StreamSupport.intStream(() ->Spliterators.spliterator(newCharIterator(),

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 defaultIntStream codePoints() {classCodePointIterator implements PrimitiveIterator.OfInt {int cur = 0;

@Overridepublic voidforEachRemaining(IntConsumer block) {

finalint length =length();int i =cur;try{while (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;

}

}publicboolean hasNext() {return cur

}public intnextInt() {

finalint length =length();if (cur >=length) {throw newNoSuchElementException();

}char c1 = charAt(cur++);if (Character.isHighSurrogate(c1) && cur

cur++;returnCharacter.toCodePoint(c1, c2);

}

}returnc1;

}

}return StreamSupport.intStream(() ->Spliterators.spliteratorUnknownSize(newCodePointIterator(),

Spliterator.ORDERED),

Spliterator.ORDERED,false);

}

}