JDK1.8源码学习--002、java.lang.String

ゞ浴缸里的玫瑰 2022-03-06 12:35 174阅读 0赞

/**
 * 说明：
 * 被 final 修饰符的修饰的类不允许被其他类继承。所以 String 是不能被我们继承的。
 */
 public final class String
 implements java.io.Serializable, Comparable<String>, CharSequence {
 
 /**
 * 说明：char属性
 * 该值用于字符存储、
 * 从JDK9开始，String对象不再以char[]形式存储，而是以名为value的byte[]形式存储。
 */
 /** The value is used for character storage. */
 private final char value[];
 
 
 /**
 * 说明：hash属性
 * 缓存字符串的哈希码、
 */
 /** Cache the hash code for the string */
 private int hash; // Default to 0
 
 /**
 * 说明：serialVersionUID属性
 * 序列化ID
 */
 /** use serialVersionUID from JDK 1.0.2 for interoperability */
 private static final long serialVersionUID = -6849794470754667710L;
 
 /**
 * Class String is special cased within the Serialization Stream Protocol.
 *
 * A String instance is written into an ObjectOutputStream according to
 * <a href="{@docRoot}/../platform/serialization/spec/output.html">
 * Object Serialization Specification, Section 6.2, "Stream Elements"</a>
 */
 /**
 * 说明：
 * 用于指定哪些字段需要被默认序列化
 */
 private static final ObjectStreamField[] serialPersistentFields =
 new ObjectStreamField[0];
 
 /**
 * Initializes a newly created {@code String} object so that it represents
 * an empty character sequence. Note that use of this constructor is
 * unnecessary since Strings are immutable.
 */
 /**
 * 说明：String构造方法
 * 一共有16个、有二个标识为@Deprecated、就是不建议使用、因为String是不可变的。所以构造方法会很多
 * 下面这个构造作用：创建空字符序列
 */
 public String() {
 this.value = "".value;
 }
 
 /**
 * Initializes a newly created {@code String} object so that it represents
 * the same sequence of characters as the argument; in other words, the
 * newly created string is a copy of the argument string. Unless an
 * explicit copy of {@code original} is needed, use of this constructor is
 * unnecessary since Strings are immutable.
 *
 * @param original
 * A {@code String}
 */
 /**
 * 说明：作用
 * 使用字符串类型的对象来初始化
 * @param original
 */
 public String(String original) {
 this.value = original.value;
 this.hash = original.hash;
 }
 
 /**
 * Allocates a new {@code String} so that it represents the sequence of
 * characters currently contained in the character array argument. The
 * contents of the character array are copied; subsequent modification of
 * the character array does not affect the newly created string.
 *
 * @param value
 * The initial value of the string
 */
 /**
 * 说明：字符数组构造方法、传一个字符数组、 Arrays.copyOf 方法或 Arrays.copyOfRange 方法。
 * 这两个方法是将原有的字符数组中的内容逐一的复制到 String 中的字符数组中。会创建一个新的字符串对象
 * 所以随后对于该字符数组的修改不会影响新创建的字符串
 * @param value
 */
 public String(char value[]) {
 this.value = Arrays.copyOf(value, value.length);
 }
 
 /**
 * Allocates a new {@code String} that contains characters from a subarray
 * of the character array argument. The {@code offset} argument is the
 * index of the first character of the subarray and the {@code count}
 * argument specifies the length of the subarray. The contents of the
 * subarray are copied; subsequent modification of the character array does
 * not affect the newly created string.
 *
 * @param value
 * Array that is the source of characters
 *
 * @param offset
 * The initial offset
 *
 * @param count
 * The length
 *
 * @throws IndexOutOfBoundsException
 * If the {@code offset} and {@code count} arguments index
 * characters outside the bounds of the {@code value} array
 */
 /**
 * 说明：功能同上、offset起始位置（起始偏移量）、count（长度）、
 * @param value
 * @param offset
 * @param count
 */
 public String(char value[], int offset, int count) {
 if (offset < 0) {
 throw new StringIndexOutOfBoundsException(offset);
 }
 if (count <= 0) {
 if (count < 0) {
 throw new StringIndexOutOfBoundsException(count);
 }
 if (offset <= value.length) {
 this.value = "".value;
 return;
 }
 }
 // Note: offset or count might be near -1>>>1.
 if (offset > value.length - count) {
 throw new StringIndexOutOfBoundsException(offset + count);
 }
 this.value = Arrays.copyOfRange(value, offset, offset+count);
 }
 
 
 /**
 * 说明：参数为int数组、起始位置、长度
 * @param codePoints
 * @param offset
 * @param count
 */
 public String(int[] codePoints, int offset, int count) {
 if (offset < 0) {
 throw new StringIndexOutOfBoundsException(offset);
 }
 if (count <= 0) {
 if (count < 0) {
 throw new StringIndexOutOfBoundsException(count);
 }
 if (offset <= codePoints.length) {
 this.value = "".value;
 return;
 }
 }
 // Note: offset or count might be near -1>>>1.
 if (offset > codePoints.length - count) {
 throw new StringIndexOutOfBoundsException(offset + count);
 }
 
 final int end = offset + count;
 
 // Pass 1: Compute precise size of char[]
 //计算数组长度
 int n = count;
 for (int i = offset; i < end; i++) {
 int c = codePoints[i];
 if (Character.isBmpCodePoint(c))
 continue;
 //代码点是否是一个有效的Unicode代码点值
 else if (Character.isValidCodePoint(c))
 n++;
 else throw new IllegalArgumentException(Integer.toString(c));
 }
 
 // Pass 2: Allocate and fill in char[]
 final char[] v = new char[n];
 
 //如果unicode字符属于BMP、就存入字符数组、
 //如果unicode字符是增补字符、需要用两个char来表示 Character.toSurrogates(c, v, j++)
 for (int i = offset, j = 0; i < end; i++, j++) {
 int c = codePoints[i];
 if (Character.isBmpCodePoint(c))
 v[j] = (char)c;
 else
 Character.toSurrogates(c, v, j++);
 }
 
 this.value = v;
 }
 
 
 @Deprecated
 public String(byte ascii[], int hibyte, int offset, int count) {
 checkBounds(ascii, offset, count);
 char value[] = new char[count];
 
 if (hibyte == 0) {
 for (int i = count; i-- > 0;) {
 value[i] = (char)(ascii[i + offset] & 0xff);
 }
 } else {
 hibyte <<= 8;
 for (int i = count; i-- > 0;) {
 value[i] = (char)(hibyte | (ascii[i + offset] & 0xff));
 }
 }
 this.value = value;
 }
 
 
 @Deprecated
 public String(byte ascii[], int hibyte) {
 this(ascii, hibyte, 0, ascii.length);
 }
 
 /* Common private utility method used to bounds check the byte array
 * and requested offset & length values used by the String(byte[],..)
 * constructors.
 */
 
 /**
 * 说明：检查字节长度的合法性
 * StringIndexOutOfBoundsException ：字符下标越界异常
 * @param bytes
 * @param offset
 * @param length
 */
 private static void checkBounds(byte[] bytes, int offset, int length) {
 if (length < 0)
 throw new StringIndexOutOfBoundsException(length);
 if (offset < 0)
 throw new StringIndexOutOfBoundsException(offset);
 if (offset > bytes.length - length)
 throw new StringIndexOutOfBoundsException(offset + length);
 }
 
 
 /**
 * 说明：字节数组构造方法、字节数组转成字符串要进行转码
 * @param bytes
 * @param offset
 * @param length
 * @param charsetName
 * @throws UnsupportedEncodingException
 *
 * StringCoding.decode、解码
 * StringCoding.encode、编码
 */
 public String(byte bytes[], int offset, int length, String charsetName) throws UnsupportedEncodingException {
 if (charsetName == null)
 throw new NullPointerException("charsetName");
 checkBounds(bytes, offset, length);
 this.value = StringCoding.decode(charsetName, bytes, offset, length);
 }
 
 
 public String(byte bytes[], int offset, int length, Charset charset) {
 if (charset == null)
 throw new NullPointerException("charset");
 checkBounds(bytes, offset, length);
 this.value = StringCoding.decode(charset, bytes, offset, length);
 }
 
 
 /**
 * 说明：
 * this():调用自已无参构造方法
 * @param bytes
 * @param charsetName
 * @throws UnsupportedEncodingException
 */
 public String(byte bytes[], String charsetName) throws UnsupportedEncodingException {
 this(bytes, 0, bytes.length, charsetName);
 }
 
 
 public String(byte bytes[], Charset charset) {
 this(bytes, 0, bytes.length, charset);
 }
 
 
 public String(byte bytes[], int offset, int length) {
 checkBounds(bytes, offset, length);
 this.value = StringCoding.decode(bytes, offset, length);
 }
 
 
 public String(byte bytes[]) {
 this(bytes, 0, bytes.length);
 }
 
 /**
 * Allocates a new string that contains the sequence of characters
 * currently contained in the string buffer argument. The contents of the
 * string buffer are copied; subsequent modification of the string buffer
 * does not affect the newly created string.
 *
 * @param buffer
 * A {@code StringBuffer}
 */
 /**
 * 说明：将StringBuffer转为String、线程安全
 * Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度
 * @param buffer
 */
 public String(StringBuffer buffer) {
 synchronized(buffer) {
 this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
 }
 }
 
 
 /**
 * 说明：将StringBuilder 转为String
 * @param builder
 */
 public String(StringBuilder builder) {
 this.value = Arrays.copyOf(builder.getValue(), builder.length());
 }
 
 /*
 * Package private constructor which shares value array for speed.
 * this constructor is always expected to be called with share==true.
 * a separate constructor is needed because we already have a public
 * String(char[]) constructor that makes a copy of the given char[].
 */
 String(char[] value, boolean share) {
 // assert share : "unshared not supported";
 this.value = value;
 }
 
 /**
 * Returns the length of this string.
 * The length is equal to the number of <a href="Character.html#unicode">Unicode
 * code units</a> in the string.
 *
 * @return the length of the sequence of characters represented by this
 * object.
 */
 /**
 * 说明：方法length()、获取字符串的长度
 * @return
 */
 public int length() {
 return value.length;
 }
 
 /**
 * Returns {@code true} if, and only if, {@link #length()} is {@code 0}.
 *
 * @return {@code true} if {@link #length()} is {@code 0}, otherwise
 * {@code false}
 *
 * @since 1.6
 */
 /**
 * 说明：判断字符串长度是否为0
 * @return
 */
 public boolean isEmpty() {
 return value.length == 0;
 }
 
 
 /**
 * 说明：给定下标, 返回该下标对应的字符数据.
 * @param index
 * @return
 */
 public char charAt(int index) {
 if ((index < 0) || (index >= value.length)) {
 throw new StringIndexOutOfBoundsException(index);
 }
 return value[index];
 }
 
 
 /**
 * 返回指定索引处的字符（Unicode代码点）。
 * @param index
 * @return
 */
 public int codePointAt(int index) {
 if ((index < 0) || (index >= value.length)) {
 throw new StringIndexOutOfBoundsException(index);
 }
 return Character.codePointAtImpl(value, index, value.length);
 }
 
 
 /**
 * 返回指定索引之前的字符（Unicode代码点）。
 * @param index
 * @return
 */
 public int codePointBefore(int index) {
 int i = index - 1;
 if ((i < 0) || (i >= value.length)) {
 throw new StringIndexOutOfBoundsException(index);
 }
 return Character.codePointBeforeImpl(value, index, 0);
 }
 
 
 /**
 * 返回此 String 的指定文本范围中的 Unicode 代码点数。
 * @param beginIndex
 * @param endIndex
 * @return
 */
 public int codePointCount(int beginIndex, int endIndex) {
 if (beginIndex < 0 || endIndex > value.length || beginIndex > endIndex) {
 throw new IndexOutOfBoundsException();
 }
 return Character.codePointCountImpl(value, beginIndex, endIndex - beginIndex);
 }
 
 
 /**
 * 返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引
 * @param index
 * @param codePointOffset
 * @return
 */
 public int offsetByCodePoints(int index, int codePointOffset) {
 if (index < 0 || index > value.length) {
 throw new IndexOutOfBoundsException();
 }
 return Character.offsetByCodePointsImpl(value, 0, value.length,
 index, codePointOffset);
 }
 
 /**
 * Copy characters from this string into dst starting at dstBegin.
 * This method doesn't perform any range checking.
 */
 /**
 * 说明： 将字符从此字符串复制到目标字符数组。
 * @param dst
 * @param dstBegin
 */
 void getChars(char dst[], int dstBegin) {
 System.arraycopy(value, 0, dst, dstBegin, value.length);
 }
 
 
 public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
 if (srcBegin < 0) {
 throw new StringIndexOutOfBoundsException(srcBegin);
 }
 if (srcEnd > value.length) {
 throw new StringIndexOutOfBoundsException(srcEnd);
 }
 if (srcBegin > srcEnd) {
 throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
 }
 System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
 }
 
 
 @Deprecated
 public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {
 if (srcBegin < 0) {
 throw new StringIndexOutOfBoundsException(srcBegin);
 }
 if (srcEnd > value.length) {
 throw new StringIndexOutOfBoundsException(srcEnd);
 }
 if (srcBegin > srcEnd) {
 throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
 }
 Objects.requireNonNull(dst);
 
 int j = dstBegin;
 int n = srcEnd;
 int i = srcBegin;
 char[] val = value; /* avoid getfield opcode */
 
 while (i < n) {
 dst[j++] = (byte)val[i++];
 }
 }
 
 
 /**
 * 说明： 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
 * @param charsetName
 * @return
 * @throws UnsupportedEncodingException
 */
 public byte[] getBytes(String charsetName)
 throws UnsupportedEncodingException {
 if (charsetName == null) throw new NullPointerException();
 return StringCoding.encode(charsetName, value, 0, value.length);
 }
 
 
 /**
 * 说明： 使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组
 * @param charset
 * @return
 */
 public byte[] getBytes(Charset charset) {
 if (charset == null) throw new NullPointerException();
 return StringCoding.encode(charset, value, 0, value.length);
 }
 
 /**
 * Encodes this {@code String} into a sequence of bytes using the
 * platform's default charset, storing the result into a new byte array.
 *
 * The behavior of this method when this string cannot be encoded in
 * the default charset is unspecified. The {@link
 * java.nio.charset.CharsetEncoder} class should be used when more control
 * over the encoding process is required.
 *
 * @return The resultant byte array
 *
 * @since JDK1.1
 */
 public byte[] getBytes() {
 return StringCoding.encode(value, 0, value.length);
 }
 
 /**
 * 说明： 将此字符串与指定的对象比较。
 * @param anObject
 * @return
 */
 public boolean equals(Object anObject) {
 if (this == anObject) {
 return true;
 }
 if (anObject instanceof String) {
 String anotherString = (String)anObject;
 int n = value.length;
 if (n == anotherString.value.length) {
 char v1[] = value;
 char v2[] = anotherString.value;
 int i = 0;
 while (n-- != 0) {
 if (v1[i] != v2[i])
 return false;
 i++;
 }
 return true;
 }
 }
 return false;
 }
 
 
 
 /**
 * 说明：将此字符串与指定的 StringBuffer 比较
 * @param sb
 * @return
 */
 public boolean contentEquals(StringBuffer sb) {
 return contentEquals((CharSequence)sb);
 }
 
 /**
 * 说明：私有类、比较二个字符串是否相同、先判字符数组长度是否相等，再逐一进行比较。
 * AbstractStringBuilder这个抽象类是StringBuilder和StringBuffer的直接父类
 * @param sb
 * @return
 */
 private boolean nonSyncContentEquals(AbstractStringBuilder sb) {
 char v1[] = value;
 char v2[] = sb.getValue();
 int n = v1.length;
 if (n != sb.length()) {
 return false;
 }
 for (int i = 0; i < n; i++) {
 if (v1[i] != v2[i]) {
 return false;
 }
 }
 return true;
 }
 
 
 /**
 * 说明：将此字符串与指定的 CharSequence 比较
 * CharSequence是一个接口，它只包括length(), charAt(int index),
 * subSequence(int start,int end)这几个API接口。除了String实现了CharSequence之外，
 * StringBuffer和StringBuilder也实现了 CharSequence接口。
 * @param cs
 * @return
 */
 public boolean contentEquals(CharSequence cs) {
 // Argument is a StringBuffer, StringBuilder
 if (cs instanceof AbstractStringBuilder) {
 if (cs instanceof StringBuffer) {
 synchronized(cs) {
 return nonSyncContentEquals((AbstractStringBuilder)cs);
 }
 } else {
 return nonSyncContentEquals((AbstractStringBuilder)cs);
 }
 }
 // Argument is a String
 if (cs instanceof String) {
 return equals(cs);
 }
 // Argument is a generic CharSequence
 char v1[] = value;
 int n = v1.length;
 if (n != cs.length()) {
 return false;
 }
 for (int i = 0; i < n; i++) {
 if (v1[i] != cs.charAt(i)) {
 return false;
 }
 }
 return true;
 }
 
 
 /**
 * 说明：将此 String 与另一个 String 比较，不考虑大小写。
 * @param anotherString
 * @return
 */
 public boolean equalsIgnoreCase(String anotherString) {
 return (this == anotherString) ? true
 : (anotherString != null)
 && (anotherString.value.length == value.length)
 && regionMatches(true, 0, anotherString, 0, value.length);
 }
 
 /**
 * 说明： 按字典顺序比较两个字符串
 * @param anotherString
 * @return
 * 首先取出两个字符串的长度，比较较小的长度内，两者是否相等。
 * 若不相等，则直接返回该位置字符的ASCII码相减后的值。
 * 若各位置都相等，则将两个字符串长度的差值返回。
 */
 public int compareTo(String anotherString) {
 int len1 = value.length;
 int len2 = anotherString.value.length;
 int lim = Math.min(len1, len2);
 char v1[] = value;
 char v2[] = anotherString.value;
 
 int k = 0;
 while (k < lim) {
 char c1 = v1[k];
 char c2 = v2[k];
 if (c1 != c2) {
 return c1 - c2;
 }
 k++;
 }
 return len1 - len2;
 }
 
 /**
 * A Comparator that orders {@code String} objects as by
 * {@code compareToIgnoreCase}. This comparator is serializable.
 * 
 * Note that this Comparator does not take locale into account,
 * and will result in an unsatisfactory ordering for certain locales.
 * The java.text package provides Collators to allow
 * locale-sensitive ordering.
 *
 * @see java.text.Collator#compare(String, String)
 * @since 1.2
 */
 public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator();
 
 private static class CaseInsensitiveComparator implements Comparator<String>, java.io.Serializable {
 
 
 // use serialVersionUID from JDK 1.2.2 for interoperability
 /**
 * 说明：serialVersionUID属性
 * Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，
 * JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，
 * 如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)
 */
 private static final long serialVersionUID = 8575799808933029326L;
 
 /**
 * 说明：忽略大小写比较器、根据源字符串是小于、等于或大于目标字符串来返回负整数、零或正整数
 * Java为了针对Georgian（格鲁吉亚）字母表奇怪的大小写转换规则而专门又增加了一步判断，就是转换成小写再比较一次
 * @param s1
 * @param s2
 * @return
 */
 public int compare(String s1, String s2) {
 int n1 = s1.length();
 int n2 = s2.length();
 int min = Math.min(n1, n2);
 for (int i = 0; i < min; i++) {
 char c1 = s1.charAt(i);
 char c2 = s2.charAt(i);
 if (c1 != c2) {
 c1 = Character.toUpperCase(c1);
 c2 = Character.toUpperCase(c2);
 if (c1 != c2) {
 c1 = Character.toLowerCase(c1);
 c2 = Character.toLowerCase(c2);
 if (c1 != c2) {
 // No overflow because of numeric promotion
 return c1 - c2;
 }
 }
 }
 }
 return n1 - n2;
 }
 
 /** Replaces the de-serialized object. */
 private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
 }
 
 
 /**
 * 说明：按字典顺序比较两个字符串、忽略大小写
 * @param str
 * @return
 */
 public int compareToIgnoreCase(String str) {
 return CASE_INSENSITIVE_ORDER.compare(this, str);
 }
 
 
 /**
 * 说明：测试两个字符串区域是否相等
 * @param toffset
 * @param other
 * @param ooffset
 * @param len
 * @return
 */
 public boolean regionMatches(int toffset, String other, int ooffset, int len) {
 char ta[] = value;
 int to = toffset;
 char pa[] = other.value;
 int po = ooffset;
 // Note: toffset, ooffset, or len might be near -1>>>1.
 if ((ooffset < 0) || (toffset < 0)
 || (toffset > (long)value.length - len)
 || (ooffset > (long)other.value.length - len)) {
 return false;
 }
 while (len-- > 0) {
 if (ta[to++] != pa[po++]) {
 return false;
 }
 }
 return true;
 }
 
 
 public boolean regionMatches(boolean ignoreCase, int toffset,
 String other, int ooffset, int len) {
 char ta[] = value;
 int to = toffset;
 char pa[] = other.value;
 int po = ooffset;
 // Note: toffset, ooffset, or len might be near -1>>>1.
 if ((ooffset < 0) || (toffset < 0)
 || (toffset > (long)value.length - len)
 || (ooffset > (long)other.value.length - len)) {
 return false;
 }
 while (len-- > 0) {
 char c1 = ta[to++];
 char c2 = pa[po++];
 if (c1 == c2) {
 continue;
 }
 if (ignoreCase) {
 // If characters don't match but case may be ignored,
 // try converting both characters to uppercase.
 // If the results match, then the comparison scan should
 // continue.
 char u1 = Character.toUpperCase(c1);
 char u2 = Character.toUpperCase(c2);
 if (u1 == u2) {
 continue;
 }
 // Unfortunately, conversion to uppercase does not work properly
 // for the Georgian alphabet, which has strange rules about case
 // conversion. So we need to make one last check before
 // exiting.
 if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
 continue;
 }
 }
 return false;
 }
 return true;
 }
 
 
 /**
 * 说明： 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
 * @param prefix
 * @param toffset
 * @return
 */
 public boolean startsWith(String prefix, int toffset) {
 char ta[] = value;
 int to = toffset;
 char pa[] = prefix.value;
 int po = 0;
 int pc = prefix.value.length;
 // Note: toffset might be near -1>>>1.
 if ((toffset < 0) || (toffset > value.length - pc)) {
 return false;
 }
 while (--pc >= 0) {
 if (ta[to++] != pa[po++]) {
 return false;
 }
 }
 return true;
 }
 
 /**
 * Tests if this string starts with the specified prefix.
 *
 * @param prefix the prefix.
 * @return {@code true} if the character sequence represented by the
 * argument is a prefix of the character sequence represented by
 * this string; {@code false} otherwise.
 * Note also that {@code true} will be returned if the
 * argument is an empty string or is equal to this
 * {@code String} object as determined by the
 * {@link #equals(Object)} method.
 * @since 1. 0
 */
 /**
 * 说明：测试此字符串是否以指定的前缀开始。
 * @param prefix
 * @return
 */
 public boolean startsWith(String prefix) {
 return startsWith(prefix, 0);
 }
 
 /**
 * Tests if this string ends with the specified suffix.
 *
 * @param suffix the suffix.
 * @return {@code true} if the character sequence represented by the
 * argument is a suffix of the character sequence represented by
 * this object; {@code false} otherwise. Note that the
 * result will be {@code true} if the argument is the
 * empty string or is equal to this {@code String} object
 * as determined by the {@link #equals(Object)} method.
 */
 
 /**
 *说明：测试此字符串是否以指定的后缀结束。
 * @param suffix
 * @return
 */
 public boolean endsWith(String suffix) {
 return startsWith(suffix, value.length - suffix.value.length);
 }
 
 
 
 /**
 * 说明：返回字符串的哈希码
 * 可以看到为了避免频繁计算哈希的开销，此处使用了 String 类的hash 属性作为缓存。
 * 在 Java 中，整型数是 32 位的，大小范围为Integer.MIN_VALUE<-->Integer.MAX_VALUE(-2147483648<–>2147483647)
 * 所以一定会有碰撞产生，即不同的字符串对应相同的哈希值。
 * @return
 */
 public int hashCode() {
 int h = hash;
 if (h == 0 && value.length > 0) {
 char val[] = value;
 
 for (int i = 0; i < value.length; i++) {
 h = 31 * h + val[i];
 }
 hash = h;
 }
 return h;
 }
 
 
 /**
 * 说明：返回指定字符在此字符串中第一次出现处的索引
 * @param ch
 * @return
 */
 public int indexOf(int ch) {
 return indexOf(ch, 0);
 }
 
 
 public int indexOf(int ch, int fromIndex) {
 final int max = value.length;
 if (fromIndex < 0) {
 fromIndex = 0;
 } else if (fromIndex >= max) {
 // Note: fromIndex might be near -1>>>1.
 return -1;
 }
 
 if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
 // handle most cases here (ch is a BMP code point or a
 // negative value (invalid code point))
 final char[] value = this.value;
 for (int i = fromIndex; i < max; i++) {
 if (value[i] == ch) {
 return i;
 }
 }
 return -1;
 } else {
 return indexOfSupplementary(ch, fromIndex);
 }
 }
 
 /**
 * Handles (rare) calls of indexOf with a supplementary character.
 */
 private int indexOfSupplementary(int ch, int fromIndex) {
 if (Character.isValidCodePoint(ch)) {
 final char[] value = this.value;
 final char hi = Character.highSurrogate(ch);
 final char lo = Character.lowSurrogate(ch);
 final int max = value.length - 1;
 for (int i = fromIndex; i < max; i++) {
 if (value[i] == hi && value[i + 1] == lo) {
 return i;
 }
 }
 }
 return -1;
 }
 
 
 public int lastIndexOf(int ch) {
 return lastIndexOf(ch, value.length - 1);
 }
 
 
 public int lastIndexOf(int ch, int fromIndex) {
 if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
 // handle most cases here (ch is a BMP code point or a
 // negative value (invalid code point))
 final char[] value = this.value;
 int i = Math.min(fromIndex, value.length - 1);
 for (; i >= 0; i--) {
 if (value[i] == ch) {
 return i;
 }
 }
 return -1;
 } else {
 return lastIndexOfSupplementary(ch, fromIndex);
 }
 }
 
 /**
 * Handles (rare) calls of lastIndexOf with a supplementary character.
 */
 private int lastIndexOfSupplementary(int ch, int fromIndex) {
 if (Character.isValidCodePoint(ch)) {
 final char[] value = this.value;
 char hi = Character.highSurrogate(ch);
 char lo = Character.lowSurrogate(ch);
 int i = Math.min(fromIndex, value.length - 2);
 for (; i >= 0; i--) {
 if (value[i] == hi && value[i + 1] == lo) {
 return i;
 }
 }
 }
 return -1;
 }
 
 
 public int indexOf(String str) {
 return indexOf(str, 0);
 }
 
 
 public int indexOf(String str, int fromIndex) {
 return indexOf(value, 0, value.length,
 str.value, 0, str.value.length, fromIndex);
 }
 
 
 static int indexOf(char[] source, int sourceOffset, int sourceCount,
 String target, int fromIndex) {
 return indexOf(source, sourceOffset, sourceCount,
 target.value, 0, target.value.length,
 fromIndex);
 }
 
 
 static int indexOf(char[] source, int sourceOffset, int sourceCount,
 char[] target, int targetOffset, int targetCount,
 int fromIndex) {
 if (fromIndex >= sourceCount) {
 return (targetCount == 0 ? sourceCount : -1);
 }
 if (fromIndex < 0) {
 fromIndex = 0;
 }
 if (targetCount == 0) {
 return fromIndex;
 }
 
 char first = target[targetOffset];
 int max = sourceOffset + (sourceCount - targetCount);
 
 for (int i = sourceOffset + fromIndex; i <= max; i++) {
 /* Look for first character. */
 if (source[i] != first) {
 while (++i <= max && source[i] != first);
 }
 
 /* Found first character, now look at the rest of v2 */
 if (i <= max) {
 int j = i + 1;
 int end = j + targetCount - 1;
 for (int k = targetOffset + 1; j < end && source[j]
 == target[k]; j++, k++);
 
 if (j == end) {
 /* Found whole string. */
 return i - sourceOffset;
 }
 }
 }
 return -1;
 }
 
 
 public int lastIndexOf(String str) {
 return lastIndexOf(str, value.length);
 }
 
 
 public int lastIndexOf(String str, int fromIndex) {
 return lastIndexOf(value, 0, value.length,
 str.value, 0, str.value.length, fromIndex);
 }
 
 
 static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
 String target, int fromIndex) {
 return lastIndexOf(source, sourceOffset, sourceCount,
 target.value, 0, target.value.length,
 fromIndex);
 }
 
 
 static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
 char[] target, int targetOffset, int targetCount,
 int fromIndex) {
 /*
 * Check arguments; return immediately where possible. For
 * consistency, don't check for null str.
 */
 int rightIndex = sourceCount - targetCount;
 if (fromIndex < 0) {
 return -1;
 }
 if (fromIndex > rightIndex) {
 fromIndex = rightIndex;
 }
 /* Empty string always matches. */
 if (targetCount == 0) {
 return fromIndex;
 }
 
 int strLastIndex = targetOffset + targetCount - 1;
 char strLastChar = target[strLastIndex];
 int min = sourceOffset + targetCount - 1;
 int i = min + fromIndex;
 
 startSearchForLastChar:
 while (true) {
 while (i >= min && source[i] != strLastChar) {
 i--;
 }
 if (i < min) {
 return -1;
 }
 int j = i - 1;
 int start = j - (targetCount - 1);
 int k = strLastIndex - 1;
 
 while (j > start) {
 if (source[j--] != target[k--]) {
 i--;
 continue startSearchForLastChar;
 }
 }
 return start - sourceOffset + 1;
 }
 }
 
 
 /**
 * 说明：返回一个从beginIndex开始的子字符串
 * @param beginIndex
 * @return
 */
 public String substring(int beginIndex) {
 if (beginIndex < 0) {
 throw new StringIndexOutOfBoundsException(beginIndex);
 }
 int subLen = value.length - beginIndex;
 if (subLen < 0) {
 throw new StringIndexOutOfBoundsException(subLen);
 }
 return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
 }
 
 
 /**
 * 说明：返回从beginIndex到endIndex的字符串
 * @param beginIndex
 * @param endIndex
 * @return
 */
 public String substring(int beginIndex, int endIndex) {
 if (beginIndex < 0) {
 throw new StringIndexOutOfBoundsException(beginIndex);
 }
 if (endIndex > value.length) {
 throw new StringIndexOutOfBoundsException(endIndex);
 }
 int subLen = endIndex - beginIndex;
 if (subLen < 0) {
 throw new StringIndexOutOfBoundsException(subLen);
 }
 return ((beginIndex == 0) && (endIndex == value.length)) ? this
 : new String(value, beginIndex, subLen);
 }
 
 
 /**
 * 说明：返回一个新的字符序列，它是此序列的一个子序列
 * @param beginIndex
 * @param endIndex
 * @return
 */
 public CharSequence subSequence(int beginIndex, int endIndex) {
 return this.substring(beginIndex, endIndex);
 }
 
 /**
 * 说明：将指定的字符串连接到该字符串的末尾。
 * @param str
 * @return
 */
 public String concat(String str) {
 int otherLen = str.length();
 if (otherLen == 0) {
 return this;
 }
 int len = value.length;
 char buf[] = Arrays.copyOf(value, len + otherLen);
 str.getChars(buf, len);
 return new String(buf, true);
 }
 
 
 /**
 *说明：在字符串中用newChar字符替代oldChar字符，返回一个新的字符串
 * @param oldChar
 * @param newChar
 * @return
 */
 public String replace(char oldChar, char newChar) {
 if (oldChar != newChar) {
 int len = value.length;
 int i = -1;
 char[] val = value; /* avoid getfield opcode */
 
 while (++i < len) {
 if (val[i] == oldChar) {
 break;
 }
 }
 if (i < len) {
 char buf[] = new char[len];
 for (int j = 0; j < i; j++) {
 buf[j] = val[j];
 }
 while (i < len) {
 char c = val[i];
 buf[i] = (c == oldChar) ? newChar : c;
 i++;
 }
 return new String(buf, true);
 }
 }
 return this;
 }
 
 
 /**
 * 说明：告诉这个字符串是否匹配给定的 regular expression
 * @param regex
 * @return
 */
 public boolean matches(String regex) {
 return Pattern.matches(regex, this);
 }
 
 
 /**
 * 说明：此字符串包含指定的char值序列时，返回true
 * @param s
 * @return
 */
 public boolean contains(CharSequence s) {
 return indexOf(s.toString()) > -1;
 }
 
 
 public String replaceFirst(String regex, String replacement) {
 return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
 }
 
 public String replaceAll(String regex, String replacement) {
 return Pattern.compile(regex).matcher(this).replaceAll(replacement);
 }
 
 
 public String replace(CharSequence target, CharSequence replacement) {
 return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
 this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
 }
 
 
 public String[] split(String regex, int limit) {
 /* fastpath if the regex is a
 (1)one-char String and this character is not one of the
 RegEx's meta characters ".$|()[{^?*+\\", or
 (2)two-char String and the first char is the backslash and
 the second is not the ascii digit or ascii letter.
 */
 char ch = 0;
 if (((regex.value.length == 1 &&
 ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
 (regex.length() == 2 &&
 regex.charAt(0) == '\\' &&
 (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
 ((ch-'a')|('z'-ch)) < 0 &&
 ((ch-'A')|('Z'-ch)) < 0)) &&
 (ch < Character.MIN_HIGH_SURROGATE ||
 ch > Character.MAX_LOW_SURROGATE))
 {
 int off = 0;
 int next = 0;
 boolean limited = limit > 0;
 ArrayList<String> list = new ArrayList<>();
 while ((next = indexOf(ch, off)) != -1) {
 if (!limited || list.size() < limit - 1) {
 list.add(substring(off, next));
 off = next + 1;
 } else { // last one
 //assert (list.size() == limit - 1);
 list.add(substring(off, value.length));
 off = value.length;
 break;
 }
 }
 // If no match was found, return this
 if (off == 0)
 return new String[]{this};
 
 // Add remaining segment
 if (!limited || list.size() < limit)
 list.add(substring(off, value.length));
 
 // Construct result
 int resultSize = list.size();
 if (limit == 0) {
 while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
 resultSize--;
 }
 }
 String[] result = new String[resultSize];
 return list.subList(0, resultSize).toArray(result);
 }
 return Pattern.compile(regex).split(this, limit);
 }
 
 
 public String[] split(String regex) {
 return split(regex, 0);
 }
 
 
 public static String join(CharSequence delimiter, CharSequence... elements) {
 Objects.requireNonNull(delimiter);
 Objects.requireNonNull(elements);
 // Number of elements not likely worth Arrays.stream overhead.
 StringJoiner joiner = new StringJoiner(delimiter);
 for (CharSequence cs: elements) {
 joiner.add(cs);
 }
 return joiner.toString();
 }
 
 
 public static String join(CharSequence delimiter,
 Iterable<? extends CharSequence> elements) {
 Objects.requireNonNull(delimiter);
 Objects.requireNonNull(elements);
 StringJoiner joiner = new StringJoiner(delimiter);
 for (CharSequence cs: elements) {
 joiner.add(cs);
 }
 return joiner.toString();
 }
 
 
 public String toLowerCase(Locale locale) {
 if (locale == null) {
 throw new NullPointerException();
 }
 
 int firstUpper;
 final int len = value.length;
 
 /* Now check if there are any characters that need to be changed. */
 scan: {
 for (firstUpper = 0 ; firstUpper < len; ) {
 char c = value[firstUpper];
 if ((c >= Character.MIN_HIGH_SURROGATE)
 && (c <= Character.MAX_HIGH_SURROGATE)) {
 int supplChar = codePointAt(firstUpper);
 if (supplChar != Character.toLowerCase(supplChar)) {
 break scan;
 }
 firstUpper += Character.charCount(supplChar);
 } else {
 if (c != Character.toLowerCase(c)) {
 break scan;
 }
 firstUpper++;
 }
 }
 return this;
 }
 
 char[] result = new char[len];
 int resultOffset = 0; /* result may grow, so i+resultOffset
 * is the write location in result */
 
 /* Just copy the first few lowerCase characters. */
 System.arraycopy(value, 0, result, 0, firstUpper);
 
 String lang = locale.getLanguage();
 boolean localeDependent =
 (lang == "tr" || lang == "az" || lang == "lt");
 char[] lowerCharArray;
 int lowerChar;
 int srcChar;
 int srcCount;
 for (int i = firstUpper; i < len; i += srcCount) {
 srcChar = (int)value[i];
 if ((char)srcChar >= Character.MIN_HIGH_SURROGATE
 && (char)srcChar <= Character.MAX_HIGH_SURROGATE) {
 srcChar = codePointAt(i);
 srcCount = Character.charCount(srcChar);
 } else {
 srcCount = 1;
 }
 if (localeDependent ||
 srcChar == '\u03A3' || // GREEK CAPITAL LETTER SIGMA
 srcChar == '\u0130') { // LATIN CAPITAL LETTER I WITH DOT ABOVE
 lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);
 } else {
 lowerChar = Character.toLowerCase(srcChar);
 }
 if ((lowerChar == Character.ERROR)
 || (lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
 if (lowerChar == Character.ERROR) {
 lowerCharArray =
 ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale);
 } else if (srcCount == 2) {
 resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount;
 continue;
 } else {
 lowerCharArray = Character.toChars(lowerChar);
 }
 
 /* Grow result if needed */
 int mapLen = lowerCharArray.length;
 if (mapLen > srcCount) {
 char[] result2 = new char[result.length + mapLen - srcCount];
 System.arraycopy(result, 0, result2, 0, i + resultOffset);
 result = result2;
 }
 for (int x = 0; x < mapLen; ++x) {
 result[i + resultOffset + x] = lowerCharArray[x];
 }
 resultOffset += (mapLen - srcCount);
 } else {
 result[i + resultOffset] = (char)lowerChar;
 }
 }
 return new String(result, 0, len + resultOffset);
 }
 
 
 public String toLowerCase() {
 return toLowerCase(Locale.getDefault());
 }
 
 
 public String toUpperCase(Locale locale) {
 if (locale == null) {
 throw new NullPointerException();
 }
 
 int firstLower;
 final int len = value.length;
 
 /* Now check if there are any characters that need to be changed. */
 scan: {
 for (firstLower = 0 ; firstLower < len; ) {
 int c = (int)value[firstLower];
 int srcCount;
 if ((c >= Character.MIN_HIGH_SURROGATE)
 && (c <= Character.MAX_HIGH_SURROGATE)) {
 c = codePointAt(firstLower);
 srcCount = Character.charCount(c);
 } else {
 srcCount = 1;
 }
 int upperCaseChar = Character.toUpperCaseEx(c);
 if ((upperCaseChar == Character.ERROR)
 || (c != upperCaseChar)) {
 break scan;
 }
 firstLower += srcCount;
 }
 return this;
 }
 
 /* result may grow, so i+resultOffset is the write location in result */
 int resultOffset = 0;
 char[] result = new char[len]; /* may grow */
 
 /* Just copy the first few upperCase characters. */
 System.arraycopy(value, 0, result, 0, firstLower);
 
 String lang = locale.getLanguage();
 boolean localeDependent =
 (lang == "tr" || lang == "az" || lang == "lt");
 char[] upperCharArray;
 int upperChar;
 int srcChar;
 int srcCount;
 for (int i = firstLower; i < len; i += srcCount) {
 srcChar = (int)value[i];
 if ((char)srcChar >= Character.MIN_HIGH_SURROGATE &&
 (char)srcChar <= Character.MAX_HIGH_SURROGATE) {
 srcChar = codePointAt(i);
 srcCount = Character.charCount(srcChar);
 } else {
 srcCount = 1;
 }
 if (localeDependent) {
 upperChar = ConditionalSpecialCasing.toUpperCaseEx(this, i, locale);
 } else {
 upperChar = Character.toUpperCaseEx(srcChar);
 }
 if ((upperChar == Character.ERROR)
 || (upperChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
 if (upperChar == Character.ERROR) {
 if (localeDependent) {
 upperCharArray =
 ConditionalSpecialCasing.toUpperCaseCharArray(this, i, locale);
 } else {
 upperCharArray = Character.toUpperCaseCharArray(srcChar);
 }
 } else if (srcCount == 2) {
 resultOffset += Character.toChars(upperChar, result, i + resultOffset) - srcCount;
 continue;
 } else {
 upperCharArray = Character.toChars(upperChar);
 }
 
 /* Grow result if needed */
 int mapLen = upperCharArray.length;
 if (mapLen > srcCount) {
 char[] result2 = new char[result.length + mapLen - srcCount];
 System.arraycopy(result, 0, result2, 0, i + resultOffset);
 result = result2;
 }
 for (int x = 0; x < mapLen; ++x) {
 result[i + resultOffset + x] = upperCharArray[x];
 }
 resultOffset += (mapLen - srcCount);
 } else {
 result[i + resultOffset] = (char)upperChar;
 }
 }
 return new String(result, 0, len + resultOffset);
 }
 
 
 public String toUpperCase() {
 return toUpperCase(Locale.getDefault());
 }
 
 
 public String trim() {
 int len = value.length;
 int st = 0;
 char[] val = value; /* avoid getfield opcode */
 
 while ((st < len) && (val[st] <= ' ')) {
 st++;
 }
 while ((st < len) && (val[len - 1] <= ' ')) {
 len--;
 }
 return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
 }
 
 /**
 * This object (which is already a string!) is itself returned.
 *
 * @return the string itself.
 */
 public String toString() {
 return this;
 }
 
 
 /**
 * 说明：将此字符串转换为新的字符数组。
 * @return
 */
 public char[] toCharArray() {
 // Cannot use Arrays.copyOf because of class initialization order issues
 char result[] = new char[value.length];
 System.arraycopy(value, 0, result, 0, value.length);
 return result;
 }
 
 
 public static String format(String format, Object... args) {
 return new Formatter().format(format, args).toString();
 }
 
 
 public static String format(Locale l, String format, Object... args) {
 return new Formatter(l).format(format, args).toString();
 }
 
 
 public static String valueOf(Object obj) {
 return (obj == null) ? "null" : obj.toString();
 }
 
 
 public static String valueOf(char data[]) {
 return new String(data);
 }
 
 
 public static String valueOf(char data[], int offset, int count) {
 return new String(data, offset, count);
 }
 
 public static String copyValueOf(char data[], int offset, int count) {
 return new String(data, offset, count);
 }
 
 
 public static String copyValueOf(char data[]) {
 return new String(data);
 }
 
 
 public static String valueOf(boolean b) {
 return b ? "true" : "false";
 }
 
 
 public static String valueOf(char c) {
 char data[] = {c};
 return new String(data, true);
 }
 
 
 public static String valueOf(int i) {
 return Integer.toString(i);
 }
 
 
 public static String valueOf(long l) {
 return Long.toString(l);
 }
 
 
 public static String valueOf(float f) {
 return Float.toString(f);
 }
 
 
 public static String valueOf(double d) {
 return Double.toString(d);
 }
 
 
 /**
 * 说明：
 * 　jdk1.6中字符串常量池存放在永久代中：
 * 当使用intern()方法时，查询字符串常量池是否存在当前字符串，
 * 若不存在则将当前字符串复制到字符串常量池中，并返回字符串常量池中的引用。
 *
 * 　　jdk1.7中字符串常量池存放在堆中：
 * 当使用intern()方法时，先查询字符串常量池是否存在当前字符串，
 * 若字符串常量池中不存在则再从堆中查询，然后存储并返回相关引用；
 * 若都不存在则将当前字符串复制到字符串常量池中，并返回字符串常量池中的引用。
 * @return
 */
 public native String intern();
 }