String 源码解析

一、charAt

返回指定位置的字符

eg:     "abcde".charAt(1)  结果为b

/**
 * Returns the {@code char} at {@code index}.
 * @throws IndexOutOfBoundsException if {@code index < 0} or {@code index >= length()}.
 */
public native char charAt(int index);

二、compareTo

两个字符串进行比较（一次只比较一个字符），结果如下：

1）遇到两个字符不同时，则结束比较，返回第一个字符与第二个字符的差值

     eg:  “abc”.compareTo("abd")   ，由于c与d不同，结束比较，返回c-d的值-1（返回的是他们ASCII差值）

2）如果两个字符串比较都相同，则比较两个字符串的长度

     eg:  “abc”.compareTo("abcd")，返回-1

                    “abc”.compareTo("abc")，返回0

/**
 * Compares this string to the given string.
 *
 * <p>The strings are compared one {@code char} at a time.
 * In the discussion of the return value below, note that {@code char} does not
 * mean code point, though this should only be visible for surrogate pairs.
 *
 * <p>If there is an index at which the two strings differ, the result is
 * the difference between the two {@code char}s at the lowest such index.
 * If not, but the lengths of the strings differ, the result is the difference
 * between the two strings' lengths.
 * If the strings are the same length and every {@code char} is the same, the result is 0.
 *
 * @throws NullPointerException
 *             if {@code string} is {@code null}.
 */
public native int compareTo(String string);

三、compareToIgnoreCase

两个字符串进行比较，忽略大小写，其他参照compareTo

/**
 * Compares this string to the given string, ignoring case differences.
 *
 * <p>The strings are compared one {@code char} at a time. This is not suitable
 * for case-insensitive string comparison for all locales.
 * Use a {@link java.text.Collator} instead.
 *
 * <p>If there is an index at which the two strings differ, the result is
 * the difference between the two {@code char}s at the lowest such index.
 * If not, but the lengths of the strings differ, the result is the difference
 * between the two strings' lengths.
 * If the strings are the same length and every {@code char} is the same, the result is 0.
 *
 * @throws NullPointerException
 *             if {@code string} is {@code null}.
 */
public int compareToIgnoreCase(String string) {
    int result;
    int end = count < string.count ? count : string.count;
    char c1, c2;
    for (int i = 0; i < end; ++i) {
        if ((c1 = charAt(i)) == (c2 = string.charAt(i))) {
            continue;
        }
        c1 = foldCase(c1);
        c2 = foldCase(c2);
        if ((result = c1 - c2) != 0) {
            return result;
        }
    }
    return count - string.count;
}

/**
 * This isn't equivalent to either of ICU's u_foldCase case folds, and thus any of the Unicode
 * case folds, but it's what the RI uses.
 */
private char foldCase(char ch) {
    if (ch < 128) {
        if ('A' <= ch && ch <= 'Z') {
            return (char) (ch + ('a' - 'A'));
        }
        return ch;
    }
    return Character.toLowerCase(Character.toUpperCase(ch));
}

四、concat

字符串拼接

（concat与+的效率问题可参考：http://blog.csdn.net/qq_34206198/article/details/51862477）

/**
 * Concatenates this string and the specified string.
 *
 * @param string
 *            the string to concatenate
 * @return a new string which is the concatenation of this string and the
 *         specified string.
 */
public native String concat(String string);

五、copyValueOf

将指定字符数组转换成字符串

/**
 * Creates a new string by copying the given {@code char[]}.
 * Modifying the array after creating the string has no
 * effect on the string.
 *
 * @throws NullPointerException
 *             if {@code data} is {@code null}.
 */
public static String copyValueOf(char[] data) {
    return StringFactory.newStringFromChars(data, 0, data.length);
}

eg：

public static void main(String[] args) {
    char[] data={'1','2','3'};
    System.out.print(String.copyValueOf(data));
}

结果：

六、copyValueOf(char[] data, int start, int length)

将指定字符数组转换成字符串

start:指定data的起始位置

length:指定需要转换的个数

/**
 * Creates a new string by copying the given subsequence of the given {@code char[]}.
 * Modifying the array after creating the string has no
 * effect on the string.

 * @throws NullPointerException
 *             if {@code data} is {@code null}.
 * @throws IndexOutOfBoundsException
 *             if {@code length < 0, start < 0} or {@code start + length >
 *             data.length}.
 */
public static String copyValueOf(char[] data, int start, int length) {
    return StringFactory.newStringFromChars(data, start, length);
}

eg：

public static void main(String[] args) {
    char[] data={'1','2','3'};
    System.out.print(String.copyValueOf(data,0,2));
}

结果：

七、endWith

判断是否以某字符串结尾

/**
 * Compares the specified string to this string to determine if the
 * specified string is a suffix.
 *
 * @throws NullPointerException
 *             if {@code suffix} is {@code null}.
 */
public boolean endsWith(String suffix) {
    return regionMatches(count - suffix.count, suffix, 0, suffix.count);
}

/**
 * Returns true if the given subsequence of the given string matches this string starting
 * at the given offset.
 *
 * @param thisStart the start offset in this string.
 * @param string the other string.
 * @param start the start offset in {@code string}.
 * @param length the number of {@code char}s to compare.
 * @throws NullPointerException
 *             if {@code string} is {@code null}.
 */
public boolean regionMatches(int thisStart, String string, int start, int length) {
    if (string == null) {
        throw new NullPointerException("string == null");
    }
    if (start < 0 || string.count - start < length) {
        return false;
    }
    if (thisStart < 0 || count - thisStart < length) {
        return false;
    }
    if (length <= 0) {
        return true;
    }
    for (int i = 0; i < length; ++i) {
        if (charAt(thisStart + i) != string.charAt(start + i)) {
            return false;
        }
    }
    return true;
}

八、equals

比较字符串与其他对象，当且仅当另一个对象为string实例，且此对象表示相同的字符队列

/**
 * Compares the given object to this string and returns true if they are
 * equal. The object must be an instance of {@code String} with the same length,
 * where for every index, {@code charAt} on each string returns the same value.
 */
@Override public boolean equals(Object other) {
    if (other == this) {
      return true;
    }
    if (other instanceof String) {
        String s = (String)other;
        int count = this.count;
        if (s.count != count) {
            return false;
        }
        // TODO: we want to avoid many boundchecks in the loop below
        // for long Strings until we have array equality intrinsic.
        // Bad benchmarks just push .equals without first getting a
        // hashCode hit (unlike real world use in a Hashtable). Filter
        // out these long strings here. When we get the array equality
        // intrinsic then remove this use of hashCode.
        if (hashCode() != s.hashCode()) {
            return false;
        }
        for (int i = 0; i < count; ++i) {
            if (charAt(i) != s.charAt(i)) {
                return false;
            }
        }
        return true;
    } else {
        return false;
    }
}

九、equalsIgonreCase

忽略大小写比较字符串与其他对象，当且仅当另一个对象为string实例，且此对象表示相同的字符队列

/**
 * Compares the given string to this string ignoring case.
 *
 * <p>The strings are compared one {@code char} at a time. This is not suitable
 * for case-insensitive string comparison for all locales.
 * Use a {@link java.text.Collator} instead.
 */
@FindBugsSuppressWarnings("ES_COMPARING_PARAMETER_STRING_WITH_EQ")
public boolean equalsIgnoreCase(String string) {
    if (string == this) {
        return true;
    }
    if (string == null || count != string.count) {
        return false;
    }
    for (int i = 0; i < count; ++i) {
        char c1 = charAt(i);
        char c2 = string.charAt(i);
        if (c1 != c2 && foldCase(c1) != foldCase(c2)) {
            return false;
        }
    }
    return true;
}