java String 篇

此文篇幅较长，若想快速查找相关信息，推荐使用 Ctrl + F键定位。

String 类代表字符串，所有的字符串都是String的实例如"abc";
字符串是常量，创建并赋值之后其值是不可更改的。字符串缓冲区支持可变字符串。因为字符串的常量性，所以他们是互通的；
例如
String str = “abc”;等价于
char data[] = {‘a’,‘b’,‘c’};
String str = new String(data);
字符串还可以这样用
System.out.println(“abc”);
String cde = “cde”;
System.out.println(“abc” + cde);
String c = “abc”.substring(2,3);
String d = cde.substring(1,2);
String类包含有
检索字符串中指定字符的函数
与字符串比较函数
查找子串函数
提取子串函数
将字符串中所有字符转换成大写/小写函数（大小写映射基于Unicode标准版本）
等函数；
对于String类的实例化，除非有特殊说明否则当传入null至构造函数时，会抛NullPointerException异常；
String类不可被继承
在String 类中有四个私有属性
字符数组value
缓存字符串的哈希码
另外两个，不清楚。
以下是源码

/** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

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

部分构造函数

String()

构造一个空字符串；

String(String str)

构造一个跟str内容一样的字符串；

String(char value[])

构造一个将字符数组的内容串起来的字符串

String(char value[], int offset, int count)

从字符数组下标为offset位置开始到长度字符串为count时的下标为止，
当offset为复数，offset + count 大于数组长度，抛java.lang.StringIndexOutOfBoundsException异常

String(int[] codePoints, int offset, int count)

将codePoint数组中的数字按Unicode编码转成字符创起来构成一个字符串

String(byte bytes[], int offset, int length, String charsetName)

从bytes数组下标为offset的元素开始构造一个长度为length按charsetName编码方式构造一个字符串
常见的编码方式有

编码方式	含义
charset=iso-8859-1	西欧的编码，英文编码
charset=gb2312	中文编码
charset=utf-8	世界通用语言编码
charset=big5	繁体中文编码
charset=euc-kr	韩文编码

String(byte bytes[], int offset, int length, Charset charset)

这个构造函数的用法和上一个不同的地方在于最后一个参数
关于最后一个参数
定义

Charset cha = Charset.forname(String Charsetname);//或者
Charset cha = Charset.defaultCharset();

Charset更多

String(byte bytes[], String charsetName)

将bytes数组中的代码点全按charsetName方式编码成字符串
代码点是抽象字符在一定整数范围内所映射的特殊整数。

String(byte bytes[], Charset charset)

将bytes数组中的代码点全按charset方式编码成字符串

String(byte bytes[], int offset, int length)

按默认编码方式将bytes数组中从元素下标为offset开始累计长度到length的下标为止，编码成字符串。

String(byte bytes[])

将bytes数组中的元素按默认方式编码成字符串

String(StringBuffer buffer)

构造与buffer内容一样的字符串；

String(StringBuilder builder)

构造与builder内容一样的字符串；

String(char[] value, boolean share)

这个构造方法是默认属性不能被调用，share只能为true
也就是String(char[] value)方法
以下是String类中的一些常用方法
String构造函数演示实例

int length()

返回字符串长度

boolean isEmpty()

判断字符串是否为空

char charAt(int index)

返回在字符串中位置为index的字符（下标从0开始）

int codePointAt(int index)

返回在字符串中位置为index的字符的Unicode码

int codePointBefore(int index)

返回当前下表前一个的Unicode码

int codePointCount(int beginIndex, int endIndex)

返回一个字符串下标从beginIndex开始到endIndex-1范围内的Unicode代码点数量
指定范围内的代码点数量和字符数量可能不一致，因为有的符号需要两个字符去表示，而它只对应一个代码点

int offsetByCodePoints(int index, int codePointOffset)

返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。偏移量codePointOffset 可正可负
关于offsetByCodePoints更详细的描述

void getChars(char dst[], int dstBegin)

内部复制方法，不可被调用。

void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin)

复制方法
srcBegin 复制起点下标
srcEnd 复制终点下标 +1
dst[] 目标字符数组
dstBegin 目标字符数组复制起点位置的下标

byte[] getBytes(String charsetName)

获得字符串以charsetName方式解码的byte[]数组

byte[] getBytes(Charset charset)

获得字符串以charset方式解码的byte[]数组

byte[] getBytes()

获得字符串按默认方式解码的byte[]数组
判断一个Object实列是否与当前字符串等值函数
源码分析
引入参数 anObject
第一个if 判断 若传进来的实例是当前实例则返回true,也就是当自己跟自己比较。
第二个if判断 传进来的参数是不是String类的实例
若不是无法比较返回false;
若是 则将anObject强制转换为String类型
然后比较两个字符串长度是否相等，不等返回false;
相等则比较两个字符串中相应位置的值是否相等，若有不等返回false;
总结 当前字符串与另一个字符串比较相等则返回true 不完全等值或则不能比较则返回false;
源码如下：

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);
    }
    
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;
    }
    
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 contentEquals(StringBuffer sb)
private boolean nonSyncContentEquals(AbstractStringBuilder sb)
public boolean contentEquals(CharSequence cs)

第一个函数是将StringBuffer类的实例与当前字符串的值进行内容相同判断。
看完代码我们知道，第一个函数与第三个函数是重载关系，第一个函数调用了第三个函数，第三个函数又调用了第二个函数。
在第三个函数中对所传进来的CharSequence 参数进行了划分
分成
AbstractStringBuilder 类型
StringBuffer 类型
String 类型
CharSequence 类型
四种类型
StringBuffer是AbstractStringBuilder 的子类
对应着四种不同的判断方法
1.AbstractStringBuilder 类型通过调用第二个函数判断
2.StringBuffer 类型将其强制转换成AbstractStringBuilder 类型再调用第二个函数判断。
3.String类型 调用equal()函数判断
4.CharSequence 类型 写挨个比值算法判断
第二个函数中的比较方法也是挨个比值
对于第一第二种比较的线程区别在于前者是非线程安全后者是线程安全。
我们可以看到在对StringBuffer 进行判断前有一个synchronized(cs) synchronized 是给对象加锁，控制线程并发的串行性；
更多关于synchronized

public boolean equalsIgnoreCase(String anotherString)
{
return (this == anotherString) ? true
                : (anotherString != null)
                && (anotherString.value.length == value.length)
                && regionMatches(true, 0, anotherString, 0, value.length);
}

这个方法是将两个字符串忽略大小写进行内容相等比较
当自己更自己比较时直接返回true，
不然再一部判断判断待比较字符串是否为空为空返回false;
否则，进一步判断待比较字符串与当前字符串长度是否相等不等返回false
否则调用regionMatches函数
这里比较妙的是使用了 (？：)运算符在冒号的后面用了两个与运算。
而与运算的特点就是只要一个结果是false则最终结果为false；所以算法的设计是将一些特殊情况放在前面一旦结果为false则后面的不用再判断直接返回结果，这样做节省了一定时间。
在代码中有一段

regionMatches(true, 0, anotherString, 0, value.length);

这个函数就是忽略字母大小写判断字符串等内容的关键算法
源码如下

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

代码中采用的方式是，将两个字符串的每个字符先用Character.toUpperCase（）转成大写比较
若不相等再转成Character.toLowerCase（）小写比较
若两种情况都不相等则返回false;
对于我们是再都转换成大写比较不相等后还要继续比较转换成小写再进行一次比较的解释是which has strange rules about case conversion.（一些特殊情况）

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

compareTo()函数
参数是一个字符串
返回值是 一个整数
当两个字符串一模一样的时候返回值是0
当传入的字符串与当前字符串从开头开始都相等但长度不同时返回的时两个字符串长度的差值
当传入的字符串在两者的最小长度范围内按次序比较第一次出现不同字符时，返回的是该处两个字符的代码点的差值。

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
        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) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }
              /** Replaces the de-serialized object. */
        private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
        }

这个私有类，就是上面那句声明里用到的类，其中实现了两个字符串忽略大小写区别的比较，返回情况跟compareTo相同另外的serialVersionUID和readResolve()我暂时不明所以。

public int compareToIgnoreCase(String str)

这个方法调用了上面类中的compare方法

public boolean regionMatches(int toffset, String other, int ooffset,int len)

判断两个字符串从各自规定的起点toffset,ooffset往后比较长度为len的那段内容是否相同。不同返回false.(起点不能为负数，各自起点加长度不可超过各自的长度不满足返回false)

public boolean startsWith(String prefix, int toffset)

判断当前字符串从toffset下标起往后的内容是否和prefix一样，一样返回true,不一样返回false.(从toffset开始到当前字符串的末位置的长度得大于等于prefix的长度)

public boolean startsWith(String prefix)

从当前字符串的初始位置开始判断往后的内容是否和prefix一样，一样为真

public boolean endsWith(String suffix)

判断当前字符串是否是以suffix字符串结尾，内部调用的是startsWith（String prefix, int toffset）函数

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

获得当前字符串的hash码
h = s[0]*31^(n-1) +s[1]*31^(n-2)+ … + s[n-1];

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

第一个方法获得字符ch的下标调用第二个方法，
第二个方法从fromIndex开始寻找ch字符在字符串中第一次出现的下标如果ch字符小于Character.MIN_SUPPLEMENTARY_CODE_POINT既属于BMP（Basic Multilingual Plane）码则直接从fromIndex开始找与ch相同的字符。找到则返回位置，找不到则返回-1；
如果ch不属于BMP码则调用indexOfSupplementary（）方法
这个方法先用Character.isValidCodePoint(ch)确定指定的代码点是否是一个有效的Unicode代码点值，然后再进一步将该代码点拆成高两位hi和低两位lo，再从fromindex开始找字符串中与ch相等的字符位置。
当字符为非BMP码时其代码点有高两位和低两位之分，四个字节，两位char字节长度，所以在字符串中占两个字符位置。
更多关于BMP与非BMP码

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

第一个方法是返回最后一个字符的下标调用了第二个方法
第二个方法是找到ch字符在该字符串中最后一次出现位置的下标当ch为非BMP范围时调用lastIndexOfSupplementary（）方法
后两种方法的算法都是从最后开始找与字符ch相同的元素并返回下标。
只不过第三种方法要比较两位字符长度才可以确定。
接下来的三种方法是找当前字符串中某段字符串str的位置

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

第一种方法 返回str在字符串中第一次出现的位置下标调用方法二，
方法二多加了一个条件从fromIndex下标开始找，调用方法三。
方法三要五个参数
char[] source 源字符串数组
,int sourceOffset, 源字符串偏移量
int sourceCount, 源字符串长度
String target 目标字符串
int fromIndex 源字符串寻找起点
接着调用了方法四方法四需要七个参数
char[] source 源字符串数组
int sourceOffset,源字符串偏移量
int sourceCount,源字符串长度
char[] target, 目标字符串数组
int targetOffset, 目标字符串偏移量
int targetCount, 目标字符串长度
int fromIndex 源字符串寻找起点
从源字符串的第fromIndex+sourceOffset元素开始往后寻找是否有与目标字符串从targetOffset开始到最后的子字符串，若有则返回第一次出现的下标，无返回-1；
当target字符串长度为0时返回位置是fromIndex.
当开始起点下标超过源字符串长度时，如果目标字符串为空则返回源字符串的长度，否则返回-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;
        }
    }

往后寻找的算法
strLastIndex 目标字符串的最后一个字符的下标
strLastChar 目标字符串的最后一个字符
min 寻找的下届
i 寻找的起点
startSearchForLastChar: continue的 标签
第一个大的循环将所有工作进行包括
第二个循环在源字符串中从i开始往后找到与strLastChar相等的字符以min为界
跳出循环，当i<min返回-1；
没有则开始 把源字符串从下标为j开始与目标函数倒序比较下界为start
如果用不同的则从i的上一个位置开始进入第一个while循环吃饭操作直到匹配到或者超出下界算法结束。

public String substring(int beginIndex)

返回从beginIndex开始之后的子串

public String substring(int beginIndex, int endIndex)

截取一段子串从beginIndex开始结束于endIndex不包括endIndex

public CharSequence subSequence(int beginIndex, int endIndex)

函数返回一个CharSequence 从beginIndex开始结束于endIndex不包括endIndex
因为String实现了接口CharSequence 所以一定得实现其中的所有函数，此函数就是其中之一。

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

返回一段由当前字符串与str连接起来的字符串
实现方法是创建一个长度为两个字符串长度和的字符数组
用Arrays.copyOf（）将一个字符串复制到字符数组上再用getChars（）方法从字符数组的len位置开始补上另一段字符串然后以该字符数组创建String实例返回；

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

将字符串中的某个字符替换成另一个字符
算法思路是这样的，先从这个字符串中找到第一个旧字符的位置然后将旧字符之前的字符放到一个新的与字符串等长的字符数组中，再接着从这个位置开始判断后续字符有无与之相等的，有则换成新字符，无则原样存入新字符数组，最后以该数组创建对象返回。
这个算法有点，绕。这样写，会直接一些；

public String replace(char oldChar, char newChar) 
 {
        if (oldChar != newChar) {
            int len = value.length;
            int i = 0;
            char[] val = value; /* avoid getfield opcode */
                while (i < len) {
                    buf[i] = (val[i] == oldChar) ? newChar : val[i];
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

public boolean matches(String regex)

matches() 方法用于检测字符串是否匹配给定的正则表达式 同为真

public boolean contains(CharSequence s) 

判断是否包含字符序列s 包含为真

public String replaceFirst(String regex, String replacement)
public String replaceAll(String regex, String replacement)
public String replace(CharSequence target, CharSequence replacement)

这三个方法是替换字符序列的方法
第一个是替换第一次匹配到的 既只换一次且是首次
第二个是替换所有相匹配的字符段
第三个参数换成了CharSequence （也可以放入String类型的参数）效果跟第二个一样。

public String[] split(String regex, int limit)
public String[] split(String regex)
{
        return split(regex, 0);
    }

split(String regex, int limit)函数将字符串以regex为分隔拆分字符串返回一个字符串数组
当limit大于零的时候，在limit小于等于分隔符最多能把字符串分隔个段数时得到的数组长度便是limit，否则得到的数组长度就是最大分隔数。
当limit为0时得到的数组是分隔符尽可能分隔字符串所得到的分隔结果，并且会忽略掉字符串最后分隔得到的空子串。
当limit是复数的时候，得到的数组是分隔符尽可能的分隔字符串所得到的结果。

public static String join(CharSequence delimiter, CharSequence... elements)
public static String join(CharSequence delimiter,Iterable<?extendsCharSequence>elements) 

函数作用将字符串片段或实现了CharSequence接口类型的数组元素，用连接符串接成一个字符串
join函数 第一个函数 第一个参数是连接符 后面的是需要连接的内容
第二个join 第一个参数是连接符 第二参数是 实现了CharSequence接口类型的数组
当数组里面有元素为null时null会作为一个字符串片段被串进新字符串；
示例：

List<String> list = new LinkedList<String>();
		list.add("I");
		list.add("lOVE");
		list.add("YOU");
		list.add(null);
String string = String.join("-", list);
System.out.println(string);

public String toUpperCase(Locale locale)
public String toUpperCase() 
public String toLowerCase(Locale locale)
public String toLowerCase()

大小写转换，有参数的参数是转换规则，无参数的按默认转换规则转换。

public String trim() 

返回剔除首位两端的空格的字符串

public char[] toCharArray()

将字符串处理成字符数组返回

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

两个静态方法，是类的方法。作用是将接收到的参数按照一定的格式串成字符串返回
第二个参数多了一个local指定的语言环境
举个简单的例子

String.format("这是一栋%s,价值%d","房子",100);//返回的结果是 这是一栋房子价值100

模式书写格式
模式匹配详情

public static String valueOf(Object obj)

返回一个对象转成String类型的字符串

public static String valueOf(char data[]

返回一个字符串内容由data中的数据组成.

public static String valueOf(char data[], int offset, int count)

返回一个长度为countd的字符串内容从data的下标为offset的元素开始。

public static String copyValueOf(char data[], int offset, int count) 

返回一个长度为countd的字符串内容从data的下标为offset的元素开始。

public static String copyValueOf(char data[])

返回一个字符串内容由data中的数据组成.

public static String valueOf(boolean b) ;

返回b的字符串形式"true",“false”;

public static String valueOf(int i)
{
        return Integer.toString(i);
    }
public static String valueOf(long l);
public static String valueOf(char c);
public static String valueOf(double d) ;

返回他们的字符串形式