关于java中String常用的几个方法的源码（容易根据方法名想当然的理解方法）

一、String.compareTo(String str)：比较两个字符串

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

由上述源码可以看出，调用此方法比较两个字符串的时候，

1、首先比较的是字符串的字符是否相等，(按照顺序进行比较，当两个字符串长度不一致的时候循环到比较短的字符串结束为止)，如果出现不相等的情况，返回两个字符的差值(自动转换为int)，然后返回。

2、如果字符相等，则返回两个字符串的长度差。

二、public int indexOf(String subStr) ：查询subStr在str中的位置

1、
public int indexOf(String str) {
        return indexOf(str, 0);
    }
2、
public int indexOf(String str, int fromIndex) {
        return indexOf(value, 0, value.length,
                str.value, 0, str.value.length, fromIndex);
    }
3、
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);
    }
4、
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;
    }

由上述源码可以看出，1方法调用了3个子方法来实现查询子字符串的位置功能

1、首先1方法在调用了返回了一个2方法（2方法存在的意义就是当使用者不想从index=0处开始查询子字符串时，可以自己输入fromIndex的值）

2、接着2方法返回了3方法（3方法存在的意义在我看来并不是开放给使用者的，而是通过3方法将str1进行处理，将有用参数传输给方法4，所以核心方法就是方法4。）

3、接着看一下核心方法4：

首先对fromIndex是否越界进行合法验证，当使用者将参数fromIndex设置为负数时，系统首先会将其合法化，即令fromIndex=0；

其次当fromIndex>=str.size()的时候，会对str1进行判断，如果str1是null，即（str1.size()==0）则返回index=fromIndex，反之返回-1。

接着，在formIndex合法的情况下，如果str1.size()==0，则index=fromIndex

然后，特殊情况判断完了，开始进行计算index，但是注意max的计算（当max用于for循环的时候就自动剔除了str1长度大于原字符串长度的特殊情况）

最后，for循环：第一个if代码块先在原字符串中找到与str1的第一个字符相等的index，接着利用第二个if代码块去对比接下来的所有字符是否全都相等，反之返回-1。 

三、public String(char value[]) 与String(char[] value, boolean share)

两个构造函数都是通过一个字符数组来实例化String字符串，

但是方法1与方法2之间的差别在哪里？

方法1、
public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

方法2、
String(char[] value, boolean share) {
        // assert share : "unshared not supported";
        this.value = value;
    }

从源码可看出来，方法1是将形参value[]中的内容复制到当前字符串数组中

方法2是直接将当前字符串数组直接指向形参value[]对象的内存地址。

因此，方法2比方法1的执行速度要快。但是，方法2是private的，因此在实例化一个字符串的时候不能直接使用该方法，

方法2仅用于String.concat方法内部，用于将拼接后的字符数组快速生成字符串返回。