本文共 13020 字，大约阅读时间需要 43 分钟。

String

接口和属性

String类是final不可继承的，用来存放字符数组的value[]也是final修饰的，这意味着String类是不可变的，一旦new出来就不能发生改变。因此对一个String类的对象进行任何修改（增加、删除、替换）之后，都会生成一个新的对象返回。

public final class String    implements java.io.Serializable, Comparable
   
    , CharSequence {
       /** The value is used for character storage. */    private final char value[];  // 数组存放字符数组    /** Cache the hash code for the string */    private int hash; // Default to 0，缓存字符串的hashCode}
   

构造方法

一般直接使用双引号的方式，默认调用构造方法生成一个String对象。构造方法很多，下面只列出常用的几种：

// 默认无参构造    public String() {        this.value = "".value;    }    // 由一个String对象构造 String str = new String("hello");    public String(String original) {        this.value = original.value;        this.hash = original.hash;    }    // 字符数组构造    public String(char value[]);    // 字符数组构造，指定偏移量和字符数目    public String(char value[], int offset, int count);    // Unicode码数组构造，指定偏移量和字符数目    public String(int[] codePoints, int offset, int count);    // 字节数组构造    public String(byte bytes[]);    // 字节数组构造，指定偏移量、数目，默认字符集    public String(byte bytes[], int offset, int length);    // 字节数组构造，指定偏移量、数目、字符集    public String(byte bytes[], int offset, int length, Charset charset);    // StringBuffer 构造，线程安全    public String(StringBuffer buffer) {        synchronized(buffer) {            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());        }    }    // StringBuilder 构造，非线程安全    public String(StringBuilder builder) {        this.value = Arrays.copyOf(builder.getValue(), builder.length());    }

常用方法

equals()和hashCode()

在涉及到比较和排序时，一般的类都需要同时重写equals()和hashCode()方法。String提供了hashCode()方法实现的模板，需要考虑String类中value字符数组中的每一个字符，将计算出的hash（int）缓存在属性hash中。

equals()

public boolean equals(Object anObject) {        // 注意！equals方法需要满足自反性、对称性、传递性        // 首先就要与自身先判断        if (this == anObject) {               return true;        }        if (anObject instanceof String) {    // 使用instanceof，如果不是，直接返回false            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;    }

hashCode()

// 计算String的int类型hash码    // hash = s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[0]    /* 根据Effective Java第9条中的描述       使用31是因为31是奇数素数，习惯上都使用素数来计算散列结果。       使用31可以用移位运算和减法代替乘法，提高效率:       31 * i == (i << 5) - i       现代的虚拟机VM都会自动完成这种优化。    */    public int hashCode() {        int h = hash;  // hash缓存，初始为0        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;    }

length()、isEmpty()、charAt()

String的length()是方法，而数组的length是属性，注意二者的区分。此外与C/C++中的字符串不同，C/C++的字符串一定是以’\0’结尾，length包括了这一个结束符，而Java中的String类中的value字符数组没有该结束符。

// 字符串长度    public int length() {        return value.length;    }    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];    }

equalsIgnoreCase()

忽略大小写的字符串比较。技巧：注意三目条件运算符和逻辑运算的使用，能够有效避免冗长的if…else…语句，使代码简洁清晰。

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

indexOf()

获取某则字符或者字符串在当前字符串中首次出现的索引。技巧：代码的重用。

// 或者字符ch（Unicode码形式）首次出现的索引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);        }    }    // 代码重用    public int indexOf(int ch) {        return indexOf(ch, 0);    }/**     * Code shared by String and StringBuffer to do searches. The     * source is the character array being searched, and the target     * is the string being searched for.     *     * @param   source       the characters being searched.     * @param   sourceOffset offset of the source string.     * @param   sourceCount  count of the source string.     * @param   target       the characters being searched for.     * @param   targetOffset offset of the target string.     * @param   targetCount  count of the target string.     * @param   fromIndex    the index to begin searching from.     */    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;    }    // 字符串首次出现的索引，从fromIndex位置开始搜索    public int indexOf(String str, int fromIndex) {        return indexOf(value, 0, value.length,                str.value, 0, str.value.length, fromIndex);    }    // 字符串首次出现的索引，代码重用    public int indexOf(String str) {        return indexOf(str, 0);    }

replace()

替换字符或字符序列，生成新的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(CharSequence target, CharSequence replacement) {        return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(                this).replaceAll(Matcher.quoteReplacement(replacement.toString()));    }

substring()

利用构造函数取子串。技巧：索引范围检查和代码重用。

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

trim()

去除首尾空格

public String trim() {        int len = value.length;        int st = 0;        char[] val = value;    /* avoid getfield opcode */        // 首部空格跳过        while ((st < len) && (val[st] <= ' ')) {            st++;        }        // 尾部空格跳过        while ((st < len) && (val[len - 1] <= ' ')) {            len--;        }        // 取子串，代码重用        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;    }

getChars()

从字符串读入数据到字符数组，注意，该方法没有进行索引边界检查。

/**     * Copy characters from this string into dst starting at dstBegin.     * This method doesn't perform any range checking.     */    void getChars(char dst[], int dstBegin) {        System.arraycopy(value, 0, dst, dstBegin, value.length);    }

concat()

连接字符串。技巧：代码重用。

//Concatenates the specified string to the end of this string.    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);   // 构造新的String对象返回    }

toCharArray()

将字符串转为字符数组。

public char[] toCharArray() {        // Cannot use Arrays.copyOf because of class initialization order issues        char result[] = new char[value.length];        System.arraycopy(value, 0, result, 0, value.length);        return result;    }

valueOf()

由boolean、char、double、int、float、long等基础类型生成String（利用包装类的toString()方法。由字符数组生成String（利用String构造函数）。将object转换为String,比obj+”“和obj.toString()都好，因为从源码中可以看出，valueOf()很好的避免了空指针异常。

public static String valueOf(char data[]) {        return new String(data);    }    public static String valueOf(int i) {        return Integer.toString(i);    }   public static String valueOf(Object obj) {          return (obj == null) ? "null" : obj.toString();     }      ......

copyValueOf(char[])

类似于构造函数，使用char数组生成String。

public static String copyValueOf(char data[]) {        return new String(data);    }

startWith()、endWith()

public boolean startsWith(String prefix, int toffset) {        char ta[] = value;        int to = toffset;        char pa[] = prefix.value;        int po = 0;        int pc = prefix.value.length;        // Note: toffset might be near -1>>>1.        if ((toffset < 0) || (toffset > value.length - pc)) {            return false;        }        while (--pc >= 0) {            if (ta[to++] != pa[po++]) {                return false;            }        }        return true;    }    // 代码重用    public boolean startsWith(String prefix) {        return startsWith(prefix, 0);    }    // 代码重用    public boolean endsWith(String suffix) {        return startsWith(suffix, value.length - suffix.value.length);    }

StringBuilder

上面提到String是不可变的对象，任何对String对象的修改最后都会返回一个全新的String对象。如果需要对字符串进行大量的修改时，可以考虑使用StringBuilder，StringBuilder继承自AbstractStringBuilder，而AbstractStringBuilder实现了Appendable接口和CharSequence接口。因此如果对StringBuilder对象进行修改，会将对象中的value[]字符数组进行扩容，之后将添加的新的字符序列添加到value[]的尾部。返回原来的对象。

对字符序列的修改，最主要的是append()和insert()，有很多重载形式。

以append(String str)为例，StringBuilder的append直接调用基类AbstractStringBuilder的append(String str)方法：

public StringBuilder append(String str) {        super.append(str);        return this;    }

基类AbstractStringBuilder的append(String str)方法首先对value[]数组进行扩容，之后调用String.getChars()方法，将添加的新值拷贝到value[]数组中。

public AbstractStringBuilder append(String str) {        if (str == null)            return appendNull();        int len = str.length();        ensureCapacityInternal(count + len);  // value[]数组扩容        str.getChars(0, len, value, count);  // 将添加的新值拷贝到value[]数组        count += len;  // 更新字符的数目        return this;   // 返回同一个StringBuilder对象    }

String.getChars()方法：主要包括索引边界检查和拷贝数组两个步骤。

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

注意：StringBuilder的构造函数中指定value[]数组的默认长度为16，即默认能够存储16个字符，如果超过16，则进行自动扩容，由于扩容一页带来一定的开销，如果能够预估最后字符序列的长度，使用重载的构造函数StringBuilder(int capacity)能够有效减小扩容开销，提高效率。另外，StringBuilder不是线程安全的。

StringBuffer

StringBuffer是StringBuilder的同步版本，所有的append()和insert()方法都使用synchronized关键字进行了锁定，是线程安全的。由于加锁互斥会带来很大的开销，如果不需要考虑多线程同时修改字符串的情况，推荐使用StringBuilder，既不会产生过多的对象，也不会因为需要加锁而产生很大的开销。