String源码分析。

我会带着你远行 2024-02-19 14:53 50阅读 0赞

/**
 * String是final修饰的，说明是不能被继承的，是最终类。 
 * 首先实现了Serializable接口用于序列化。 
 * 然后实现了Comparable接口，实现compareTo()方法来用于对比当前对象和传入对象的大小。 
 * 最后实现了CharSequence接口，实现length()方法,charAt()方法，subSequence()方法 
 */
 public final class String
 implements java.io.Serializable, Comparable<String>, CharSequence {
 // value[]是用于存储数据的
 private final char value[];
 // 缓存当前字符串的HashCod值,默认值为零
 private int hash; 
 
 private static final long serialVersionUID = -6849794470754667710L;
 // 这个类主要用来提取序列化过程中某个对象内的字段【成员属性】元数据信息， 包括字段的类型、类型代码、签名等 
 private static final ObjectStreamField[] serialPersistentFields =
 new ObjectStreamField[0];
 /**
 * 初始化并分配默认值空
 */
 public String() {
 this.value = new char[0];
 }
 /**
 * 初始化，并分配相应的hash值和value值，副本
 * @param original	字符串
 */
 public String(String original) {
 this.value = original.value;
 this.hash = original.hash;
 }
 /**
 * 初始化，把传入的参数数组赋值到当前对象的value值中
 * @param value	数组
 */
 public String(char value[]) {
 this.value = Arrays.copyOf(value, value.length);
 }
 /**
 * 初始化，从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) {
 throw new StringIndexOutOfBoundsException(count);
 }
 // 起始点不能超过当前数组长度减去需要长度的值，出现越界问题
 if (offset > value.length - count) {
 throw new StringIndexOutOfBoundsException(offset + count);
 }
 this.value = Arrays.copyOfRange(value, offset, offset+count);
 }
 /**
 * 初始化，从offset开始，长度为count的子数组
 * @param codePoints	父数组
 * @param offset	起始点
 * @param count	长度
 */
 public String(int[] codePoints, int offset, int count) {
 if (offset < 0) {
 throw new StringIndexOutOfBoundsException(offset);
 }
 if (count < 0) {
 throw new StringIndexOutOfBoundsException(count);
 }
 if (offset > codePoints.length - count) {
 throw new StringIndexOutOfBoundsException(offset + count);
 }
 
 final int end = offset + count;
 /*
 * 计算n的值，用于创建返回值的长度
 	 */
 int n = count;
 for (int i = offset; i < end; i++) {
 int c = codePoints[i];
 if (Character.isBmpCodePoint(c)) // 判断是否为BMP代码点（也就是16位）
 continue;
 else if (Character.isValidCodePoint(c))// 判断c是不是一个有效的代码单元，即（右移16位小于17）
 n++;
 else throw new IllegalArgumentException(Integer.toString(c));
 }
 /*
 	 * 创建返回值，从offset开始,end结束
 	 */
 final char[] v = new char[n];
 
 for (int i = offset, j = 0; i < end; i++, j++) {
 int c = codePoints[i];
 if (Character.isBmpCodePoint(c)) // 判断是否为BMP代码点（也就是16位），如果是强转赋值
 v[j] = (char)c;
 else
 Character.toSurrogates(c, v, j++);// 超过16位的处理
 }
 
 this.value = v;
 }
 /**
 	 * 用于对字节数组进行边界检查的通用私有工具类. 
 	 * @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);
 }
 	/**
 	 * 初始化，调用StringCoding工具类的decode方法指定编码名称进行转码，并解析出字符串对象
 	 * @param bytes	数组
 	 * @param offset	起始位置
 	 * @param length	长度
 	 * @param charsetName	字符集编码名称
 	 * @throws UnsupportedEncodingException
 	 */
 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);
 }
 	/**
 	 * 初始化，调用StringCoding工具类的decode方法指定编码对象进行转码，并解析出字符串对象
 	 * @param bytes	数组
 	 * @param offset	起始位置
 	 * @param length	长度
 	 * @param charset	字符集编码对象
 	 */
 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);
 }
 	/**
 	 * 初始化，指定相应的字符集名称把数组解析成字符串
 	 * @param bytes	数组
 	 * @param charsetName	字符集编码名称
 	 * @throws UnsupportedEncodingException
 	 */
 public String(byte bytes[], String charsetName)
 throws UnsupportedEncodingException {
 this(bytes, 0, bytes.length, charsetName);
 }
 	/**
 	 * 初始化，指定相应的字符集对象把数组解析成字符串
 	 * @param bytes	数组
 	 * @param charset	字符集编码对象
 	 */
 public String(byte bytes[], Charset charset) {
 this(bytes, 0, bytes.length, charset);
 }
 	/**
 	 * 初始化，根据当前Java虚拟机的默认字符集并指定起始位置和长度解析字符串
 	 * @param bytes	数组
 	 * @param offset	起始位置
 	 * @param length	长度
 	 */
 public String(byte bytes[], int offset, int length) {
 checkBounds(bytes, offset, length);
 this.value = StringCoding.decode(bytes, offset, length);
 }
 	/**
 	 * 初始化，根据当前Java虚拟机的默认字符集解析字符串
 	 * @param bytes	数组
 	 */
 public String(byte bytes[]) {
 this(bytes, 0, bytes.length);
 }
 	/**
 	 * 初始化，根据StringBuffer对象生成字符串，是线程安全的
 	 * @param buffer	StringBuffer对象
 	 */
 public String(StringBuffer buffer) {
 synchronized(buffer) {
 this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
 }
 }
 	/**
 	 * 初始化，根据StringBuilder对象生成字符串
 	 * @param builder builder对象
 	 */
 public String(StringBuilder builder) {
 this.value = Arrays.copyOf(builder.getValue(), builder.length());
 }
 	/**
 	 * 初始化，包专用构造函数，用于提升速度。
 	 * @param value	数组
 	 * @param share	总是为true
 	 */
 String(char[] value, boolean share) {
 // assert share : "unshared not supported";
 this.value = value;
 }
 	/**
 	 * 获取字符串长度。 
 	 * 一个char字符占2个字节刚好16个bit，即 一个字符串的长度等于它包含的字符个数。 
 	 */
 public int length() {
 return value.length;
 }
 	/**
 	 * 判断当前字符串是否为空
 	 * @return
 	 */
 public boolean isEmpty() {
 return value.length == 0;
 }
 	/**
 	 * 根据索引位置获取相应的字段
 	 */
 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);
 }
 	/**
 	 * index索引位置的字符往后偏移codePointOffset个索引位置，返回偏移后的索引位置 
 	 * @param index	某个字符的索引位置，是个基准点 
 	 * @param codePointOffset Unicode代码点的偏移量 
 	 * @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);
 }
 	/**
 	 * 从dstBegin开始，将当前字符串中的字符复制到dst中
 	 * @param dst	目标数组
 	 * @param dstBegin	起始值
 	 */
 void getChars(char dst[], int dstBegin) {
 System.arraycopy(value, 0, dst, dstBegin, value.length);
 }
 	/**
 	 * 将当前字符串复制到dst数组里，从srcBegin开始到 dstbegin + (srcEnd-srcBegin) - 1处
 	 * @param srcBegin	当前字符串开始复制
 	 * @param srcEnd	当前字符串结束复制
 	 * @param dst	 目标数组
 	 * @param dstBegin	目标数组起始位置
 	 */
 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);
 }
 	/**
 	 * 根据指定的字符集编码名称返回相应的数组
 	 * @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);
 }
 	/**
 	 * 根据指定的字符集编码对象返回相应的数组
 	 * @param charset	字符集编码对象
 	 * @return
 	 */
 public byte[] getBytes(Charset charset) {
 if (charset == null) throw new NullPointerException();
 return StringCoding.encode(charset, value, 0, value.length);
 }
 	/**
 	 * 根据当前Java虚拟机的默认字符集返回相应的数组
 	 * @return
 	 */
 public byte[] getBytes() {
 return StringCoding.encode(value, 0, value.length);
 }
 	/**
 	 * 将当前字符串与对象相比较
 	 */
 public boolean equals(Object anObject) {
 if (this == anObject) {
 return true;
 }
 if (anObject instanceof String) {// 是否为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	StringBuffer对象
 	 * @return
 	 */
 public boolean contentEquals(StringBuffer sb) {
 synchronized (sb) {
 return contentEquals((CharSequence) sb);
 }
 }
 	/**
 	 * 将当前字符串与指定的CharSequence比较。
 	 * @param cs	CharSequence对象
 	 * @return
 	 */
 public boolean contentEquals(CharSequence cs) {
 if (value.length != cs.length())
 return false;
 // 参数是StringBuffer，StringBuilder
 if (cs instanceof AbstractStringBuilder) {
 char v1[] = value;
 char v2[] = ((AbstractStringBuilder) cs).getValue();
 int i = 0;
 int n = value.length;
 while (n-- != 0) {// 比对数组内的值 
 if (v1[i] != v2[i])
 return false;
 i++;
 }
 return true;
 }
 // 参数是 String
 if (cs.equals(this))
 return true;
 // 参数是一个通用的CharSequence
 char v1[] = value;
 int i = 0;
 int n = value.length;
 while (n-- != 0) {// 比对数组内的值 
 if (v1[i] != cs.charAt(i))
 return false;
 i++;
 }
 return true;
 }
 /**
 * 将当前字符串与指定字符串比较，忽略大小写。
 * @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);
 }
 /**
 * 按照字典顺序比较两个字符串
 */
 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;// 字符的Unicode值进行比较
 }
 k++;
 }
 return len1 - len2;
 }
 /**
 * 字符串忽略大小比较器，实现了Serializable接口。 
 * 注意，此比较器没有考虑地区设置，并且会导致对某些地区不满意的排序。
 * java.text包下的Collators类提供了语言环境敏感的字符串顺序。 
 */
 public static final Comparator<String> CASE_INSENSITIVE_ORDER
 = new CaseInsensitiveComparator();
 private static class CaseInsensitiveComparator
 implements Comparator<String>, java.io.Serializable {
 private static final long serialVersionUID = 8575799808933029326L;
 
 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) {
 // 因为存在数字晋升机制，因此此处不会存在数据类型溢出问题
 return c1 - c2;
 }
 }
 }
 }
 return n1 - n2;
 }
 }
 /**
 * 按字典顺序比较两个字符串，不考虑大小写。
 * @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;
 }
 /**
 * 比较两个字符串的指定区域内的字符序列是否相等 
 * @param ignoreCase	是否忽略大小写
 * @param toffset	当前字符串的起始位置
 * @param other	指定字符串
 * @param ooffset	指定字符串的起始位置
 * @param len	指定字符串的长度
 * @return
 */
 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;
 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) {
 // 转换大写，进行比对
 char u1 = Character.toUpperCase(c1);
 char u2 = Character.toUpperCase(c2);
 if (u1 == u2) {
 continue;
 }
 //非常不幸的是，Character.toUpperCase()在转换成大写时对于格鲁吉亚字母不能正常工作， 
 //因为格鲁吉亚字母拥有怪异的大小写转换规则，因此我们需要在当前循环退出之前再进行一次字符比较检查
 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;
 if ((toffset < 0) || (toffset > value.length - pc)) {
 return false;
 }
 while (--pc >= 0) {
 if (ta[to++] != pa[po++]) {
 return false;
 }
 }
 return true;
 }
 /**
 * 检查当前字符串是否以指定前缀开始。
 * @param prefix 前缀
 * @return
 */
 public boolean startsWith(String prefix) {
 return startsWith(prefix, 0);
 }
 /**
 * 检查当前字符串是否以指定后缀结尾。
 * @param suffix	后缀
 * @return
 */
 public boolean endsWith(String suffix) {
 return startsWith(suffix, value.length - suffix.value.length);
 }
 /**
 * 计算当前字符串的hashcode值，计算公式为： 
 * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 
 * 上面的n表示字符串的长度，^表示求幂运算 
 * 空字符串""的hashcode值为零 
 */
 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);
 }
 /**
 * 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
 * @param ch	Unicode code point表示的一个字符，取值范围为[0, 0xFFFF) 
 * @param fromIndex	指定索引
 * @return
 */
 public int indexOf(int ch, int fromIndex) {
 final int max = value.length;
 if (fromIndex < 0) {
 fromIndex = 0;
 } else if (fromIndex >= max) {
 return -1;
 }
 
 if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {// 若ch参数小于0x010000
 // 处理大部分情况，比如ch参数是一个合法的BMP代码点， 
 // 或者ch是一个负数即非法的代码点 
 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);// 字符属于Unicode补充代码点情况
 }
 }
 /**
 * 字符属于Unicode补充代码点情况 
 * @param ch	Unicode code point表示的一个字符，取值范围为[0, 0xFFFF)	
 * @param fromIndex	从哪个索引位置开始查找
 * @return
 */
 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);
 }
 /**
 * 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
 * @param ch	Unicode code point表示的一个字符，取值范围为[0, 0xFFFF)
 * @param fromIndex 从哪个索引位置开始查找
 * @return
 */ 
 public int lastIndexOf(int ch, int fromIndex) {
 if (ch < Character.MIN_SUPPLEMENTARY_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);
 }
 }
 /**
 * 处理补充字符的最后一次出现索引位置计算 
 * @param ch	Unicode code point表示的一个字符，取值范围为[0, 0xFFFF)
 * @param fromIndex	 从哪个索引位置开始查找
 * @return
 */
 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;
 }
 /**
 * 返回指定子字符串在此字符串中第一次出现处的索引
 * @param str	指定子字符串
 * @return
 */
 public int indexOf(String str) {
 return indexOf(str, 0);
 }
 /**
 * 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
 * @param str	指定子字符串
 * @param fromIndex	指定的索引
 * @return
 */
 public int indexOf(String str, int fromIndex) {
 return indexOf(value, 0, value.length,
 str.value, 0, str.value.length, fromIndex);
 }
 /**
 * 返回指定目标字符数组的[targetOffset,targetOffset + targetCount]区间内字符序列 
 * 在源字符数组的[sourceOffset,sourceOffset + sourceCount]区间内字符序列中 
 * 第一次出现的索引位置 
 * @param source 待搜索的源字符数组 
 * @param sourceOffset 源字符数组搜索的起始偏移量 
 * @param sourceCount 源字符数组从起始偏移量位置开始往后搜索的字符个数 
 * @param target 待搜索的目标字符数组 
 * @param targetOffset 目标字符数组搜索的起始偏移量 
 * @param targetCount 目标字符数组从起始偏移量位置开始往后搜索的字符个数 
 * @param fromIndex 开始搜索的起始索引位置 
 * @return
 */
 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++) {
 // 查找第一个字符
 if (source[i] != first) {
 while (++i <= max && source[i] != first);
 }
 
 /* 找到第一个字符了，看其他部分 */
 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) {// 到目标字符结尾
 return i - sourceOffset;
 }
 }
 }
 return -1;
 }
 /**
 * 返回指定字符串在当前字符串对象中的最后一次出现的索引位置 
 * @param str	指定字符串
 * @return
 */
 public int lastIndexOf(String str) {
 return lastIndexOf(str, value.length);
 }
 /**
 * 返回指定字符串在当前字符串对象中的最后一次出现的索引位置 
 * @param str	指定字符串
 * @param fromIndex	最后一次出现的索引位置
 * @return
 */
 public int lastIndexOf(String str, int fromIndex) {
 return lastIndexOf(value, 0, value.length,
 str.value, 0, str.value.length, fromIndex);
 }
 /** 
 * 返回指定目标字符数组的[targetOffset,targetOffset + targetCount]区间内字符序列 
 * 在源字符数组的[sourceOffset,sourceOffset + sourceCount]区间内字符序列中 
 * 最后一次出现的索引位置 
 * 
 * @param source 待搜索的源字符数组 
 * @param sourceOffset 源字符数组搜索的起始偏移量 
 * @param sourceCount 源字符数组从起始偏移量位置开始往后搜索的字符个数 
 * @param target 待搜索的目标字符数组 
 * @param targetOffset 目标字符数组搜索的起始偏移量 
 * @param targetCount 目标字符数组从起始偏移量位置开始往后搜索的字符个数 
 * @param fromIndex 开始搜索的起始索引位置 
 */ 
 static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
 char[] target, int targetOffset, int targetCount,
 int fromIndex) {
 int rightIndex = sourceCount - targetCount;
 if (fromIndex < 0) {
 return -1;
 }
 if (fromIndex > rightIndex) {
 fromIndex = rightIndex;
 }
 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;
 }
 }
 /**
 * 返回当前字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。
 * @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 - 1 处的字符。
 * 因此，该子字符串的长度为 endIndex-beginIndex。 
 * @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);
 }
 	/**
 	 * 截取当前字符串的长度，从start开始，end结束
 	 */
 public CharSequence subSequence(int beginIndex, int endIndex) {
 return this.substring(beginIndex, endIndex);
 }
 	/**
 	 * 将指定字符串连接到此字符串的结尾。 如果参数字符串的长度为 0，则返回此 String 对象。否则，创建一个新的 String 对象。
 	 * @param str	连接到此String结尾的String
 	 * @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得到的。 
 * 如果 oldChar 在此 String 对象表示的字符序列中没有出现，则返回对此 String 对象的引用。
 * 否则，创建一个新的 String 对象，它所表示的字符序列除了所有的 oldChar 都被替换为 newChar 之外，
 * 与此 String 对象表示的字符序列相同。 
 * @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; // 避免直接操作value属性
 
 while (++i < len) {// 查询所有的旧字符
 if (val[i] == oldChar) {
 break;
 }
 }
 if (i < len) { // 当存在旧值时
 char buf[] = new char[len];
 for (int j = 0; j < i; j++) {// 获取到值放到buf中
 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;
 }
 /**
 * 检测当前字符串是否符合给定的正则表达式 
 * @param regex 正则表达式
 * @return
 */
 public boolean matches(String regex) {
 return Pattern.matches(regex, this);
 }
 /**
 * 当且仅当此字符串包含指定的 char 值序列时，返回 true
 * @param s	指定的CharSequence对象
 * @return
 */
 public boolean contains(CharSequence s) {
 return indexOf(s.toString()) > -1;
 }
 /**
 * 根据给定的正则表达式替换当前字符串匹配到的第一个子字符串为参数replacement表示的字符串 
 * 注意：replacement参数中若包含反斜杠\和美元符号$可能会与直接将其当做纯文本替换字符串 
 * 返回的结果不一致.如果你需要抑制特殊字符的潜在含义，那么你可能会需要使用 
 * java.util.regex.Matcher类的quoteReplacement方法来实现当前方法的功能。默认情况下, 
 * 当前方法是采用java.util.regex.Matcher类的replaceFirst方法实现的. 
 * 
 * @param regex 给定的正则表达式 
 * @param replacement 替换字符串 
 * @return
 */
 public String replaceFirst(String regex, String replacement) {
 return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
 }
 /** 
 * 根据给定的正则表达式替换当前字符串匹配到的所有子字符串为参数replacement表示的字符串 
 * 注意：replacement参数中若包含反斜杠\和美元符号$可能会与直接将其当做纯文本替换字符串 
 * 返回的结果不一致.如果你需要抑制特殊字符的潜在含义，那么你可能会需要使用 
 * java.util.regex.Matcher类的quoteReplacement方法来实现当前方法的功能。默认情况下, 
 * 当前方法是采用java.util.regex.Matcher类的replaceAll方法实现的. 
 * 
 * @param regex 给定的正则表达式 
 * @param replacement 替换字符串 
 * @return
 */
 public String replaceAll(String regex, String replacement) {
 return Pattern.compile(regex).matcher(this).replaceAll(replacement);
 }
 /** 
 * 将当前字符串中第一次出现的target字符序列替换为replacement字符序列 
 * 注意：若target或replacement参数中包含了正则表达式中的特殊字符，会一律 
 * 按照纯文本字符去理解，不会被理解为它在正则表达式中表达的含义， 
 * 即当前方法不支持正则表达式. 
 * @param target 被替换的字符序列 
 * @param replacement 替换的字符序列 
 */
 public String replace(CharSequence target, CharSequence replacement) {
 return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
 this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
 }
 /**
 * 根据给定的正则表达式来分割当前字符串并返回一个字符串数组 
 * 如果给定的正则表达式不匹配当前字符串，那么返回的字符串数组将只包含一个元素即 
 * 当前字符串对象.返回的字符串数组中的每个子字符串与它们在当前字符串中出现的顺序 
 * 保持一致. 
 * limit参数用于控制给定的正则表达式应用的次数，从而影响最终返回的字符串数组的长度. 
 * 若limit参数大于零，那么给定的正则表达式则会至多应用limit - 1次,同时最终返回的 
 * 字符串数组的长度将不大于limit,并且该数组的最后一个元素为前一个子字符串匹配后剩余 
 * 的部分。比如： 
 * "Hello world, Java" --> split(" ",2); 
 * return: "Hello" "world, Java" 
 * 若limit参数是一个负数,那么给定的正则表达式将会尽可能多的应用多次并且返回的字符串 
 * 数组的长度将会没有限制. 
 * 若limit参数为零,那么给定的正则表达式将会尽可能多的应用多次并且返回的字符串 
 * 数组的长度将会没有限制,尾部的空字符串将会被丢弃. 
 * @param regex 表示分隔符的正则表达式 
 * @param limit 限制返回的字符串数组长度的阈值 
 * @return
 */
 public String[] split(String regex, int limit) {
 /** 
 * 分3种情况处理： 
 * 1. regex参数只有一个字符且该字符串不是正则表达式中的特殊字符 .$|()[{^?*+\ 或者 
 * 2. regex参数为2个字符,第一个字符是一个反斜杠\,第二个字符为非ASCII码字母或非ASCII码数字 
 * 3. regex参数超过2个字符并且为合法的正则表达式 
 * 前2种情况采用fastpath方式进行处理，后面第3种情况采用Pattern.split(this, limit)方法实现 
 */ 
 char ch = 0;
 // 判断regex是否满足上述的前两种情况
 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中
 list.add(substring(off, next));
 off = next + 1;
 } else { // 最后一个
 list.add(substring(off, value.length));
 off = value.length;
 break;
 }
 }
 // off为零，当前字符串与给定的regex参数不匹配，那么直接返回一个字符串数组 
 // 并且该字符串数组只包含一个元素且该元素为当前字符串对象
 if (off == 0)
 return new String[]{this};
 // 添加剩余部分
 if (!limited || list.size() < limit)
 list.add(substring(off, value.length));
 // 构建最终返回的结果
 int resultSize = list.size();
 if (limit == 0)
 while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
 resultSize--;
 String[] result = new String[resultSize];
 //这里使用了list.subList方法，而该方法返回的SubList对象会在内部维护当前List对象， 
 //对SubList对象中的元素的操作会直接反映到其内部维护的List对象中,若SubList对象没有 
 //被回收，那么内部维护的List对象也不会被回收，内部维护的List中保存的对象也不会被回收， 
 //若内部维护的List是一个超大的集合，那么就会很容易发生OOM异常 
 //应该通过new ArrayList(list.subList(0, resultSize).toArray(result)); 
 //这种方式来解决这种隐患 
 return list.subList(0, resultSize).toArray(result);
 }
 // 若regex参数超过2个字符并且是合法的正则表达式，那么直接调用Pattern类的.split(this, limit) 
 // 来完成实现 
 return Pattern.compile(regex).split(this, limit);
 }
 /**
 * 根据给定正则表达式的匹配拆分此字符串。
 * @param regex 正则表达式 
 * @return
 */
 public String[] split(String regex) {
 return split(regex, 0);
 }
 /**
 * 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
 * 大小写映射关系基于 Character 类指定的 Unicode 标准版。
 * 由于大小写映射关系并不总是 1:1 的字符映射关系，
 * 因此所得 String 的长度可能不同于原 String。
 * @param locale	使用此语言环境的大小写转换规则
 * @return
 */
 public String toLowerCase(Locale locale) {
 if (locale == null) {
 throw new NullPointerException();
 }
 
 int firstUpper;
 final int len = value.length;
 /* 先扫描出前面本身已经是小写形式的字符 */
 scan: {
 for (firstUpper = 0 ; firstUpper < len; ) {
 char c = value[firstUpper];
 // 若当前字符在High Surrogate的字符范围内 
 if ((c >= Character.MIN_HIGH_SURROGATE)
 && (c <= Character.MAX_HIGH_SURROGATE)) {
 int supplChar = codePointAt(firstUpper);
 if (supplChar != Character.toLowerCase(supplChar)) {
 break scan;
 }
 // 通过Character.charCount计算实际字符的个数
 firstUpper += Character.charCount(supplChar);
 } else {
 if (c != Character.toLowerCase(c)) {
 break scan;
 }
 firstUpper++;
 }
 }
 return this;
 }
 
 char[] result = new char[len];
 int resultOffset = 0; 
 /* 复制第一个小写字符 */
 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;
 //从firstUpper索引位置开始,后面的字符都是需要进行小写处理的
 for (int i = firstUpper; i < len; i += srcCount) {
 srcChar = (int)value[i];
 //若当前字符是HIGH SURROGATE 
 if ((char)srcChar >= Character.MIN_HIGH_SURROGATE
 && (char)srcChar <= Character.MAX_HIGH_SURROGATE) {
 //获取实际的Unicode代码点
 srcChar = codePointAt(i);
 //计算实际字符长度 
 srcCount = Character.charCount(srcChar);
 } else {
 srcCount = 1;
 }
 // 特殊大写字母
 if (localeDependent || srcChar == '\u03A3') { 
 lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);
 } else if (srcChar == '\u0130') {
 lowerChar = Character.ERROR;
 } else {//一般情况,直接Character.toLowerCase()方式转换成小写
 lowerChar = Character.toLowerCase(srcChar);
 }
 //若转换后得到的是错误字符,或者是一个Unicode补充代码点 
 if ((lowerChar == Character.ERROR)
 || (lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
 if (lowerChar == Character.ERROR) {
 if (!localeDependent && srcChar == '\u0130') {
 lowerCharArray =
 ConditionalSpecialCasing.toLowerCaseCharArray(this, i, Locale.ENGLISH);
 } else {
 lowerCharArray =
 ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale);
 }
 } else if (srcCount == 2) {
 resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount;
 continue;
 } else {
 lowerCharArray = Character.toChars(lowerChar);
 }
 //得到最终小写字符数组的长度 
 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);
 }
 /**
 * 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
 * @return
 */
 public String toLowerCase() {
 return toLowerCase(Locale.getDefault());
 }
 /** 
 * 使用给定Local的大小写形式的转换规则将当前字符串对象的字符序列中包含的每个字符转换成大写形式 
 * 由于大小写映射并不总是以1:1的形式进行字符映射,因此可能会导致转换后的字符串长度与原字符串的长度 
 * 不一致. 
 * @param locale 语言环境对象，不同的语言环境下的大小写字符转换规则不同 
 * @return 返回当前字符串对象的大写形式 
 * /
 public String toUpperCase(Locale locale) {
 if (locale == null) {
 throw new NullPointerException();
 }
 
 int firstLower;
 final int len = value.length;
 //从firstLower 索引位置开始,后面的字符都是需要进行大写处理的
 scan: {
 for (firstLower = 0 ; firstLower < len; ) {
 int c = (int)value[firstLower];
 int srcCount;
 //若当前字符是HIGH SURROGATE 
 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;
 }
 
 char[] result = new char[len]; 
 int resultOffset = 0; 
 
 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);
 }
 
 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);
 }
 /**
 * 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
 * @return
 */
 public String toUpperCase() {
 return toUpperCase(Locale.getDefault());
 }
 /**
 * 返回字符串的副本，去除掉两端的空白字符
 * @return
 */
 public String trim() {
 int len = value.length;
 int st = 0;
 char[] val = value;
 //从开头开始找空白字符 
 while ((st < len) && (val[st] <= ' ')) {
 st++;
 }
 //从末尾往开头找空白字符 
 while ((st < len) && (val[len - 1] <= ' ')) {
 len--;
 }
 //若没找到空白字符，则直接返回当前字符串对象，否则截取字符串并返回 
 return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
 }
 /**
 * 返回此对象本身（它已经是一个字符串！）
 * @return
 */ 
 public String toString() {
 return this;
 }
 /**
 * 将此字符串转换为一个新的字符数组
 * @return
 */ 
 public char[] toCharArray() {
 char result[] = new char[value.length];
 System.arraycopy(value, 0, result, 0, value.length);
 return result;
 }
 /**
 * 使用指定的格式字符串和参数返回一个格式化字符串。 
 * 始终使用 Locale.getDefault() 返回的语言环境。 
 * @param format	 字符串格式参数 
 * @param args	字符串格式中需要替换的参数 
 * @return
 */
 public static String format(String format, Object... args) {
 return new Formatter().format(format, args).toString();
 }
 /**
 * 使用指定的语言环境、格式字符串和参数返回一个格式化字符串
 * @param l	 格式化过程中要应用的语言环境。如果 l 为 null，则不进行本地化
 * @param format	字符串格式参数 
 * @param args	字符串格式中需要替换的参数 
 * @return
 */
 public static String format(Locale l, String format, Object... args) {
 return new Formatter(l).format(format, args).toString();
 }
 /**
 * 返回 Object 参数的字符串表示形式
 * @param obj	object参数
 * @return
 */
 public static String valueOf(Object obj) {
 return (obj == null) ? "null" : obj.toString();
 }
 /**
 * 返回 char 数组参数的字符串表示形式。
 * 字符数组的内容已被复制，后续修改不会影响新创建的字符串。 
 * @param data	char数组
 * @return
 */
 public static String valueOf(char data[]) {
 return new String(data);
 }
 /**
 * 将指定的字符数组的[offset,offset + count]区间内的字符序列转换成一个字符串对象 
 * @param data	字符数组
 * @param offset	起始位置
 * @param count	截取的字符个数
 * @return
 */
 public static String valueOf(char data[], int offset, int count) {
 return new String(data, offset, count);
 }
 /** 
 * 将指定的字符数组的[offset,offset + count]区间内的字符序列转换成一个字符串对象 
 * 同valueOf(char data[], int offset, int count)方法实现细节一模一样，仅仅只是方法名称不同 
 */ 
 public static String copyValueOf(char data[], int offset, int count) {
 return new String(data, offset, count);
 }
 /** 
 * 将指定的字符数组转换成一个字符串对象 
 * 同valueOf(char data[])方法的具体实现细节一模一样，仅仅只是方法名称不同 
 * 
 * @param data 字符数组对象 
 * @return 返回一个新的字符串对象 
 */ 
 public static String copyValueOf(char data[]) {
 return new String(data);
 }
 /**
 * 返回 boolean 参数的字符串表示形式
 * @param b 一个 boolean
 * @return
 */ 
 public static String valueOf(boolean b) {
 return b ? "true" : "false";
 }
 /** 
 * 将单个字符转换成一个字符串对象 
 * 
 * @param c 一个字符 
 * @return 
 */ 
 public static String valueOf(char c) {
 char data[] = {c};
 return new String(data, true);
 }
 /** 
 * 将int数字转换成一个字符串对象 
 * 内部实际是调用Integer.toString()方法实现的 
 * 
 * @param i int数字 
 * @return 返回一个int类型的数字的字符串表示形式 
 * @see java.lang.Integer#toString(int, int) 
 */ 
 public static String valueOf(int i) {
 return Integer.toString(i);
 }
 /** 
 * 将long数字转换成一个字符串对象 
 * 内部实际是调用Long.toString()方法实现的 
 * 
 * @param l long类型的数字 
 * @return 返回一个long类型的数字的字符串表示形式 
 * @see java.lang.Long#toString(long) 
 */ 
 public static String valueOf(long l) {
 return Long.toString(l);
 }
 /** 
 * 将float数字转换成一个字符串对象 
 * 内部实际是调用Float.toString()方法实现的 
 * 
 * @param f float类型的数字 
 * @return 返回一个float类型的数字的字符串表示形式 
 * @see java.lang.Float#toString(float) 
 */ 
 public static String valueOf(float f) {
 return Float.toString(f);
 }
 /** 
 * 将double数字转换成一个字符串对象 
 * 内部实际是调用Double.toString()方法实现的 
 * 
 * @param d double类型的数字 
 * @return 返回一个double类型的数字的字符串表示形式 
 * @see java.lang.Double#toString(double) 
 */ 
 public static String valueOf(double d) {
 return Double.toString(d);
 }
 /** 
 * 返回字符串对象的规范化表示形式 
 * 字符串常量池初始化默认是空的，它由String类私下管理维护 
 * 当intern方法被执行，如果字符串常量池已经包含了与当前字符串对象equals的字符串, 
 * 那么直接从字符串常量池里返回该字符串对象即可,否则会将该字符串对象添加到常量池中 
 * 并返回. 
 */
 public native String intern();
 // Hash计算需要的种子
 private static final int HASHING_SEED;
 
 static {
 //当前的纳秒数 
 long nanos = System.nanoTime();
 //当前的毫秒数 
 long now = System.currentTimeMillis();
 //Hash种子利用了String类和System类的加载路径以及当前系统时间的纳秒数、毫秒数 
 int SEED_MATERIAL[] = {
 System.identityHashCode(String.class),
 System.identityHashCode(System.class),
 (int) (nanos >>> 32),
 (int) nanos,
 (int) (now >>> 32),
 (int) now,
 (int) (System.nanoTime() >>> 2)
 };
 // 内部实现避免加载类 
 int h1 = 0;
 // Hash种子计算的核心部分 
 for (int k1 : SEED_MATERIAL) {
 k1 *= 0xcc9e2d51;
 k1 = (k1 << 15) | (k1 >>> 17);
 k1 *= 0x1b873593;
 
 h1 ^= k1;
 h1 = (h1 << 13) | (h1 >>> 19);
 h1 = h1 * 5 + 0xe6546b64;
 }
 
 h1 ^= SEED_MATERIAL.length * 4;
 
 h1 ^= h1 >>> 16;
 h1 *= 0x85ebca6b;
 h1 ^= h1 >>> 13;
 h1 *= 0xc2b2ae35;
 h1 ^= h1 >>> 16;
 
 HASHING_SEED = h1;
 }
 /** 存储另一种Hash散列算法的计算结果,因为int占4个字节共32个bit,因此这里得到的是32位的Hash值 */ 
 private transient int hash32 = 0;
 /** 
 * 针对当前字符串对象计算得到一个32位的Hash值 
 * 
 * @return a 返回一个32位的Hash值 
 */ 
 int hash32() {
 int h = hash32;
 if (0 == h) {
 // Murmur3 hashing函数针对碰撞攻击提供了优秀的保护机制 
 h = sun.misc.Hashing.murmur3_32(HASHING_SEED, value, 0, value.length);
 // 确保最终计算的Hash值不为零，如果计算后得到为零, 
 // 强制赋值为1,以避免重复进行Hash计算 
 h = (0 != h) ? h : 1;
 
 hash32 = h;
 }
 return h;
 }
 
 }

参考jdk api。

参考博文：[https://iamyida.iteye.com/blog/2344166][https_iamyida.iteye.com_blog_2344166]

[https_iamyida.iteye.com_blog_2344166]: https://iamyida.iteye.com/blog/2344166