Java String源码解析——常用方法（一）

1 regionMatches

• 源码：ignoreCase 是否忽略大小写；toffset 调用者的字符下标；other 被比较的字符串；ooffset 被比较者的字符下标；len 调用者和被比较者比较的字符个数。例如"abcdef".regionMatches(true, 0, “sssABCDExxx”, 3, 4)，就是拿abcd和ABCD进行忽略大小写的比较。

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

2 String静态内部类CaseInsensitiveComparator

• compare(String s1, String s2)——大小写不敏感比较方法。把s1和s2逐个比较，先转为大写比较，再转为小写比较。如果结果返回0表示字符串相同，如果不等于0，表示字符串不相同。

private static class CaseInsensitiveComparator
    implements Comparator<String>, java.io.Serializable {
    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; }
}

• 问题1：为什么不先判断两个字符串的长度？如果长度不相等，这两个字符串就不相等了呀
  • 答案：未有
• 问题2：为什么需要转大写进行比较，还需要转小写进行比较？
  • 答案：因为Georgian（格鲁吉亚）字母表，在转成大写之后不能正常工作，所以需要转大写后，再转为小写。详情见String类的public boolean regionMatches(boolean ignoreCase, int toffset,String other, int ooffset, int len)中的一段代码注释

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

• 问题3：既然格鲁吉亚字母表在转为大写时会出现问题，那么是否可以直接进行小写比较，不需要进行大写比较呢？
  • 答案：我在Fantasy_Virgo——对于CaseInsensitiveComparator的看法
    中找到了一些线索——某些语言的只有大写形式，没有小写形式，所以JDK团队为了严谨，对大小写均进行了比较。

3 isEmpty()

• 源码

public boolean isEmpty() {
    return value.length == 0;
}

• 注意
  （1）该方法可能导致NPE，因为这行value.length == 0;

4 substring

• 源码：substring是调用了String的构造器，来重新生成一个字符串返回给调用者；而String是调用了Arrays（数组工具类）的copyOfRange方法；而Arrays的copyOfRange实际上是调用了System的public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length)方法。最后完成了字符串的截取。

	public String substring(int beginIndex, int endIndex) {
        // 如果开始下标小于0，抛出字符串下标越界异常
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        // 如果结束下标大于字符串长度，抛出字符串下标越界异常
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        // 如果结束下标-开始下标小于0，抛出字符串下标越界异常
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        // 如果开始下标=0并且结束下标=字符数组长度，返回当前字符数组，否则进行字符串截取
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }

	public String(char value[], int offset, int count) {
		// 如果开始下标小于0，抛出字符串下标越界异常
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
        	// 如果要截取的长度小于0，抛出字符串下标越界异常
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            // 返回空串
            if (offset <= value.length) {
                this.value = "".value;
                return;
            }
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

	public static char[] copyOfRange(char[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        char[] copy = new char[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

	public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

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

• 注意：该方法也可能会导致NPE，因为这行int len = value.length;

6 equals

• 源码：先比较内存地址是否相等，如果相等返回true；如果不想等，再比较内容是否相等。

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

• 注意：该方法也可能会导致NPE，因为当this为null时（null值并不是String类型），调用了String的equals()方法，那么就会出现NPE。所以使用equals()方法时，应这样写"abc".equals(obj);而不是obj.equals(“abc”)。

7 equalsIgnoreCase

• 源码：先比较两个对象的内存地址是否相等，如果相等，返回true；如果不相等，再判断比较对象是否为null、字符串长度是否相等、两个字符串忽略大小写进行比较，三者结果取与。

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

8 compareTo：根据字符串中每个字符的Unicode编码进行比较

• 源码
  • 例如：str1.compareTo(str2)
  • str1 = str2，返回0
  • str1 != str2，如果有字符串为空串，返回str1.length - str2.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;
    }

9 compareToIgnoreCase：根据字符串中每个字符的Unicode编码进行忽略大小写比较

• 源码
  • 实际上是调用了String静态内部类CaseInsensitiveComparator的compare(String s1, String s2)方法。

	public int compareToIgnoreCase(String str) {
		// public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator();
        return CASE_INSENSITIVE_ORDER.compare(this, str);
    }

10 concat：追加字符串到当前字符串

• 源码

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

• （1）System.arraycopy()方法，进行数组扩容。

   public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,  Math.min(original.length, newLength));
        return copy;
    }

• （2）System.arraycopy()方法，将字符串追加到原串上。

	void getChars(char dst[], int dstBegin) {
        System.arraycopy(value, 0, dst, dstBegin, value.length);
    }

11 indexOf 检查源串中是否有目标串的字节

• 源码
  • 简单说，在源串中含有目标串的子集，返回开始下标；否则返回-1。

	static int indexOf(char[] source, //源串
						int sourceOffset, //从源串哪个下标开始
						int sourceCount, //源串总长度
						char[] target, //要查找的目标串
						int targetOffset, //目标串从哪个下标开始
						int targetCount, //目标串总长度
						int fromIndex // 用户指定的开始下标
						) {
		// 如果开始下标大于等于源串总长度
        if (fromIndex >= sourceCount) {
        	// 如果目标串总长度等于0，返回源串总长度，否则返回-1
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        // 如果目标串长度等于0，返回开始下标
        if (targetCount == 0) {
            return fromIndex;
        }
		// 目标串要比较的第一个字符
        char first = target[targetOffset];
        // 最大比较次数=源串比较开始下标+（源串长度-目标串长度）
        int max = sourceOffset + (sourceCount - targetCount);
		// 开始比较下标=源串比较开始下标+用户指定的开始下标
        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            // 如果源串字符不等于目标串字符
            if (source[i] != first) {
            	// 循环，找到源串字符等于目标串字符的那个下标
                while (++i <= max && source[i] != first);
            }
			// 如果i <= max，说明找到第一个目标串字符等于源串字符的字符时；否则就是没找到，说明这两个字符串一点都不相同，直接返回-1。
            if (i <= max) {
                int j = i + 1;
                // 改变循环结束条件
                int end = j + targetCount - 1;
                // 从第一个相等字符往后继续匹配，如果不匹配就中断，返回-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;
    }

12 contains：是否包含目标字符串

• 源码

	public boolean contains(CharSequence s) {
        return indexOf(s.toString()) > -1;
    }

 	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, //源串总长度
						char[] target, //要查找的目标串
						int targetOffset, //目标串从哪个下标开始
						int targetCount, //目标串总长度
						int fromIndex // 用户指定的开始下标
						) {