String源码的常用功能解析

最新推荐文章于 2023-07-27 14:55:24 发布
刀在花丛中
最新推荐文章于 2023-07-27 14:55:24 发布
阅读量103
点赞数
分类专栏：常用工具类的源码解析文章标签： string 源码
本文链接：https://blog.csdn.net/qq_29070549/article/details/122416318
版权
常用工具类的源码解析专栏收录该内容
10 篇文章 0 订阅
订阅专栏
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence{
    private final char value[];//String底层是char类型数组
    private int hash;//hash值
    private static final long serialVersionUID = -6849794470754667710L;//序列号
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];//创建ObjectStreamField类数组的第一个元素
    //无参构造器，调用value方法初始化value
    public String() {
        this.value = "".value;
    	}
    //有参构造器，调用value、hash方法初始化value、hash
	public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    	}
    //有参构造器，初始化value
    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    	}
    //有参构造器，将参数中的value数组中从offset开始的count个元素初始化value
    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;
            }
        }
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    	}
    //有参构造器，传入的参数是StringBuffer，初始化value
    public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
       	 }
    	}
    //有参构造器，传入的参数是StringBuilder，初始化value
    public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
    }
    //返回字符串长度
    public int length() {
        return value.length;
    }
    //判断字符串是否为null
    public boolean isEmpty() {
        return value.length == 0;
    }
    //返回字符串的index索引位置的字符
	public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }
    //dst数组的dstBegin索引位置开始替换为字符串
	void getChars(char dst[], int dstBegin) {
        System.arraycopy(value, 0, dst, dstBegin, value.length);
    }
    //dst数组的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);
    }
    //跟上面的区别在于目标数组是byte类型，需要先进行强转
	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;
        while (i < n) {
            dst[j++] = (byte)val[i++];
        }
    }
    //判断字符串是否跟anObject，要考虑长度
	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;
    }
	public boolean contentEquals(StringBuffer sb) {
        return contentEquals((CharSequence)sb);
    }
	//跟上面一样，比较对象是AbstractStringBuilder类的对象
    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类的对象
	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;
    }
    //忽视大小写的比较
	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;
            }
            k++;
        }
        return len1 - len2;
    }
    //返回一个CaseInsensitiveComparator对象
	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;//序列号
		//规则跟compareTo相同，区别在于不考虑大小写
        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;
        }
		private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
    }
    //字符串跟str比较，不区分大小写
	public int compareToIgnoreCase(String str) {
        return CASE_INSENSITIVE_ORDER.compare(this, str);
    }
    //字符串从toffset开始的len长度区间，other从ooffset开始的长度区间，判断两个区间字符串是否相等
	public boolean regionMatches(int toffset, String other, int ooffset,
            int len) {
        char ta[] = value;
        int to = toffset;
        char pa[] = other.value;
        int po = ooffset;
        //如果参数不合理，直接返回false
        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;
    }
    //跟上面的一样，如果ignoreCase为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;
        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;
                } 
                if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                    continue;
                }
            }
            return false;
        }
        return true;
    }
    //判断字符串的索引位置toffset是否以prefix开头的
	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;
    }
    //判断字符串是否以prefix开头的
	public boolean startsWith(String prefix) {
        return startsWith(prefix, 0);
    }
    //判断字符串是否以suffix为结尾的
	public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }
    //计算字符串的hash值，并返回
	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;
    }
    //返回str在字符串出现的位置
	public int indexOf(String str) {
        return indexOf(str, 0);
    }
    //返回str在字符串fromIndex开始后出现的位置
	public int indexOf(String str, int fromIndex) {
        return indexOf(value, 0, value.length,
                str.value, 0, str.value.length, fromIndex);
    }
    //返回target在source的[fromIndex,fromIndex + sourceCount]出现的位置
	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);
    }
    //这里的fromIndex指的是source指定区间内要从哪个位置开始，target的[targetOffset,targetOffset + targetCount]字符串在source的[fromIndex,fromIndex + sourceCount]出现的位置
	static int indexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount,
            int fromIndex) {
        if (fromIndex >= sourceCount) {//如果fromIndex不小于sourceCount，说明剩下的长度不够，需要先处理
        							   //如果targetCount是0，说明要比较的只是一个元素，直接返回sourceCount
        							   //如果targetCount非0，返回-1
            return (targetCount == 0 ? sourceCount : -1);
        }
        //排除掉上面的情况后
        //fromIndex不合理，强制改为0
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        //如果targetCount为0，直接返回fromIndex
        if (targetCount == 0) {
            return fromIndex;
        }
        char first = target[targetOffset];//保存target的指定区间第一个元素
        int max = sourceOffset + (sourceCount - targetCount);//表示在source遍历的最大下标位置
        //下面用到的while、for没有具体的方法体，只是靠条件控制
        //先通过while寻找第一个元素相同的位置
        //然后通过for依次比较是否相同
        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            if (source[i] != first) {//如果第一个元素就不相等，通过while循环查找相等的位置
                while (++i <= max && source[i] != first);
            }
            if (i <= max) {//如果找到了相等的位置
                int j = i + 1;//保存下一个索引值
                int end = j + targetCount - 1;//保存不能大于的下标位置用于下个for循环控制
                for (int k = targetOffset + 1; j < end && source[j]
                        == target[k]; j++, k++);
                if (j == end) {//说明上面的for一直循环到结束，条件都成立，说明这两个区间的字符串是相等的
                    return i - sourceOffset;//则返回匹配的字符串第一个元素的索引值（相当于fromIndex自增后的结果）
                }
            }
        }
        return -1;
    }
    //str在字符串最后一次出现的位置
	public int lastIndexOf(String str) {
        return lastIndexOf(str, value.length);
    }
    //str在字符串[0,fromIndex]区间中，最后一次出现的位置
	public int lastIndexOf(String str, int fromIndex) {
        return lastIndexOf(value, 0, value.length,
                str.value, 0, str.value.length, fromIndex);
    }
    //target在source[sourceCount,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);
    }
    //跟indexOf相反，target的[targetOffset,targetOffset + targetCount]字符串在source的[sourceCount,fromIndex]最后一次出现的位置
	static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount,
            int fromIndex) {
        int rightIndex = sourceCount - targetCount;
        //跟正向查找的不同，这里直接返回-1
        if (fromIndex < 0) {
            return -1;
        }
        //如果fromIndex > rightIndex，说明原数组区间长度太小，不够比较，则强行修正
        if (fromIndex > rightIndex) {
            fromIndex = rightIndex;
        }
        if (targetCount == 0) {
            return fromIndex;
        }		
        int strLastIndex = targetOffset + targetCount - 1;//表示target区间最后一个元素的下标
        char strLastChar = target[strLastIndex];//保存target区间最后一个元素
        int min = sourceOffset + targetCount - 1;//保存source的[sourceOffset,sourceOffset+sourceCount]要比较的最后一个元素最小下标
        int i = min + fromIndex;//保存source的[sourceOffset,fromIndex]最后一个元素需要遍历的最大下标
        startSearchForLastChar: 
        while (true) {
            while (i >= min && source[i] != strLastChar) {
                i--;
            }//先寻找target区间最后一个元素在source区间相等的位置
            if (i < min) {//如果没找到，就返回-1
                return -1;
            }
            //下面就是找到的情况（注意这里i已经变化了）
            int j = i - 1;//保存前一个元素的索引值
            int start = j - (targetCount - 1);//保存要比较的首位置索引值
            int k = strLastIndex - 1;//保存target区间次最后的索引值
            while (j > start) {
                if (source[j--] != target[k--]) {//如果比较过程中出现不相等，则继续i自减，返回到之前的whlie继续寻找
                    i--;
                    continue startSearchForLastChar;
                }
            }
            return start - sourceOffset + 1;//如果while全部循环成立，说明已找到匹配的子字符串，返回子字符串首位置的索引值
        }
    }
    //返回字符串从beginIndex开始的子字符串
	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]区间的子字符串
	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);
    }
    //在字符串追加str
	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);
    }
    //将字符串中所有oldChar的字符替换为newChar
	public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value;

            while (++i < len) {//寻找字符串中匹配的第一个字符位置
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {//如果上面循环后，已找到匹配的位置，进行复制
                char buf[] = new char[len];
                //先复制i之前的所有元素
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                //然后i之后（包括i）所有出现匹配的字符替换为newChar，否则还是原样复制
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }
    //返回与regex正则表达式匹配的子字符串
	public boolean matches(String regex) {
        return Pattern.matches(regex, this);
    }
    //判断字符串是否包含s
	public boolean contains(CharSequence s) {
        return indexOf(s.toString()) > -1;
    }
    //将字符串中与regex正则表达式匹配的第一个子字符串替换为replacement
	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);
    }
    //字符串按照regex分割
    //只能按照单个字符分割，如果需要按照特殊字符分割，需要加上转义字符
    //limit是分割次数，如果limit为0，不限次数，但是会过滤掉末尾的空格，limit小于0，也不限次数，但是不会过滤末尾的空格，如果大于0，代表分割后的个数上限
	public String[] split(String regex, int limit) {
        char ch = 0;    
        if (((regex.value.length == 1 &&
             ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) || //如果regex只有一个字符，先排除特殊符号
             (regex.length() == 2 && //如果regex有两个字符，第一个字符需要是\，第二个字符需要排除0-9、字母、以及非常特殊的符号
              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) {//如果limit不大于0，或者大于集合个数+1（说明切割的个数还没有达到limit的上限）
                    list.add(substring(off, next));//切割后的字符串加入ArrayList数组（这里的截取是前闭后开）
                    off = next + 1;
                } else {//如果limit大于0，经过循环后已经不大于集合个数+1，那么最后一个元素不再进行分割
                    list.add(substring(off, value.length));
                    off = value.length;
                    break;
                }
            }
            //如果循环后off还是0，说明没有匹配到，则直接返回原字符串
            if (off == 0)
                return new String[]{this};
			//如果经过上面的循环后，集合元素还没有达到limit的上限，剩下的子字符串作为一个元素添加
            if (!limited || list.size() < limit)
                list.add(substring(off, value.length));
            int resultSize = list.size();//保存集合最终的元素个数
            if (limit == 0) {//如果切割次数为0，如果集合中分割的最后一个元素为空，则resultSize自减一个，代表舍弃掉末尾为空的元素
                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);
    }
    //字符串按照regex分割，过滤掉末尾空格
	public String[] split(String regex) {
        return split(regex, 0);
    }
    //按本地语言将字符串的字母全部变为小写
    //涉及到编码和代码点，就不用深究
	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];
                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; 
        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' || 
                srcChar == '\u0130') { 
                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() {
        return toUpperCase(Locale.getDefault());
    }
    //
	public String trim() {
        int len = value.length;
        int st = 0;
        char[] val = value; 
		//下面两个while都是寻找首尾最后一个空格
        while ((st < len) && (val[st] <= ' ')) {
            st++;
        }
        while ((st < len) && (val[len - 1] <= ' ')) {
            len--;
        }
        //如果st或者len不是初始位置，说明有空格，进行substring截取，反之直接返回原字符串
        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
    }
    //直接返回本类
	public String toString() {
        return this;
    }
    //将字符串转换为集合
	public char[] toCharArray() {
        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();
    }
    //返回obj的toString结果
	public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }
    //将data的char数组转化为String
	public static String valueOf(char data[]) {
        return new String(data);
    }
    //将data的char数组中[offset,offset+count]转化为String
	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);
    }
    //将data的char数组转化为String
	public static String copyValueOf(char data[]) {
        return new String(data);
    }
    //返回b的值
	public static String valueOf(boolean b) {
        return b ? "true" : "false";
    }
    //将c转为字符串
	public static String valueOf(char c) {
        char data[] = {c};
        return new String(data, true);
    }
    //将i转为字符串
	public static String valueOf(int i) {
        return Integer.toString(i);
    }
    //将l转为字符串
	public static String valueOf(long l) {
        return Long.toString(l);
    }
    //将f转为字符串
	public static String valueOf(float f) {
        return Float.toString(f);
    }
    //将d转为字符串
	public static String valueOf(double d) {
        return Double.toString(d);
    }
    //返回字符串在常量池中地址值
	public native String intern();
    }