(28) 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.      //如果起始地址小于0或者（起始地址+所比较对象长度）大于自身对象长度，返回假      if ((toffset < 0) || (toffset > value.length - pc)) {          return false;      }      //从所比较对象的末尾开始比较      while (--pc >= 0) {          if (ta[to++] != pa[po++]) {              return false;          }      }      return true;  }

(29) public boolean startsWith(String prefix) {

return startsWith(prefix, 0);  }

(30) public boolean endsWith(String suffix) {

return startsWith(suffix, value.length - suffix.value.length);  } 起始比较和末尾比较都是比较经常用得到的方法，例如在判断一个字符串是不是http协议的， 或者初步判断一个文件是不是mp3文件，都可以采用这个方法进行比较。

(31) public native String intern();

intern方法是Native调用，它的作用是在方法区中的常量池里通过equals方法寻找等值的对象，

如果没有找到则在常量池中开辟一片空间存放字符串并返回该对应String的引用，否则直接返回常量池中已存在String对象的引用

(32) public String toLowerCase() {

return toLowerCase(Locale.getDefault()); }

(33) 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);}将字符串的大写转换为小写，将字符串小写转换为大写

（34）public char[] toCharArray() {

char result[] = new char[value.length];      System.arraycopy(value, 0, result, 0, value.length);      return result;  }将字符串转化为数组，由于本身就是数组的形式，只需将其拷贝即可。

（35） public String[] split(String regex, int limit) {

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
    
      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);}
    

（36）public String[] split(String regex) {

return split(regex, 0); }对于字符串 "boo:and:foo",regex为o,limit为5时，splite方法首先去字符串里查找regex——o，然后把o做为分隔符，逐个把o去掉并且把字符串分开，比如，发现b后面有一个o，于是把这个o去掉，并且把字符串拆成"b", "o:and:foo"两个字符串（注意：b后面的两个o已经去掉了一个），接下来看"o:and:foo"这个字符串，第一个字符就是o，于是o前面相当于一个空串，把这个o去掉，"o:and:foo"被分开成"", ":and:foo"这样两个字符串，以此类推循环5次就是splite("o", 5)方法的作用

(37) 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(); }

(38) public static String join(CharSequence delimiter,

Iterable
     elements) {    Objects.requireNonNull(delimiter);    Objects.requireNonNull(elements);    StringJoiner joiner = new StringJoiner(delimiter);    for (CharSequence cs: elements) {        joiner.add(cs);    }    return joiner.toString();}将已给的数组用给定的字符进行分开，返回一个特定的字符串，例如String [] strings = {"a","b","c","d"}; info =  String.join( "a",strings ); System.out.println( info );打印的结果为 aabacad

（39） public static String format(String format, Object... args) {

return new Formatter().format(format, args).toString();  }

（40） public static String format(Locale l, String format, Object... args) {

return new Formatter(l).format(format, args).toString();  }  将字符串串格式化为一定格式的形式返回给

（41） 各种各样的 valueOf(Object obj) 方法

作用就是将相应格式的对象转换为你字符串的格式