JDK1.7-String源码详解

本文主要是介绍JDK1.7-String源码详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

    String表示字符串，是char的有序集合，在java中所有的字符串值，都是String的实例。
    String类提供了很多方法，如获取字符串中的字符，比较字符串，查询字符等。
    Java给String的 + 操作提供了很好的支持，相加后会返回一个字符常量结果。

String类是不可变(final)的,对String类的任何改变,都是返回一个新的String类对象。所以任何对String的修改操作 (如+) 都会重新创建一个String对象。如果想要动态地操作，可以自己来维护一个char数组，或者使用StringBuilder/StringBuffer。

String是char的有序集合，体现在String内部就是char的数组，所以本质是在操作char。String内部维护着一个char数组，一切对String的操作都是对char数组的操作。因为String的不可变性，此处也要使用final来修饰。

private final char value[];

由上，String的构造函数就很容易理解了，可以传入一个char数组，或者传入一个String对象，然后把char数组值copy过去，更新size等值就可以了。
这里的copy是有必要的，避免受到原引用的影响。

public String(char value[]) {int size = value.length;this.offset = 0;this.count = size;this.value = Arrays.copyOf(value, size);}
public String(String original) {int size = original.count;char[] originalValue = original.value;char[] v;if (originalValue.length > size) {    // 判断size范围int off = original.offset;v = Arrays.copyOfRange(originalValue, off, off + size);} else {v = originalValue;}this.offset = 0;this.count = size;this.value = v;}

Arrays.copyOf()最终会调用System.arraycopy()，后者是java的数组copy中最原始的方法，再底层就是本地方法了，所以只要是数组copy最好都用这个。
在第二个构造函数，传String对象的时候，需要判断size和offset的关系，因为String的值不一定是整个char数组都是有效的，这里赋值只取有效部分。

offset

在String中，使用offset属性来指定第一个有效的字符的位置，从这个开始到char数组的末尾都是有效地。从此处看出，String实际上是一个char数组中连续的字符串。

    private final int offset;

另外，使用count属性来保存有效char数组的长度，就是(value.size – offset)。很多地方校验String的长度，或者是否为空，都使用了这个属性。

    private final int count;public int length() {return count;}public boolean isEmpty() {return count == 0;}

     在一般情况下，offset都等于0，所以count = value.size。那么offset这个属性有什么意义呢？
    其实，offset可以用在String对象的复用上，有时候一些返回部分字串的方法，如substring()等，就可以通过修改offset属性，来获取源String的一部分，反正String对象是不可变的，所以不会交叉影响。
    不过在JDK的String上，还没有使用到这样的逻辑，涉及到修改String的都是重新创建一个新的对象，如下面的substring()。

    public String substring(int beginIndex, int endIndex) {if (beginIndex < 0) throw new StringIndexOutOfBoundsException(beginIndex);if (endIndex > count) throw new StringIndexOutOfBoundsException(endIndex);if (beginIndex > endIndex) throw new StringIndexOutOfBoundsException(endIndex - beginIndex);return ((beginIndex == 0) && (endIndex == count)) ? this : new String(offset + beginIndex, endIndex - beginIndex, value);}

在截取String前，需要进行index范围的校验，如果超出范围会抛出异常。和js以及php等不用，这里不会自动去根据String的值来调整截取范围，这也是Java强类型的一个体现吧。

equals

    判断字符串是否相等，实际上是比较两个char数组：
1、判断是否同一个对象；
2、判断是否String对象；
3、循环其中的char数组，看元素和次序是否都相等。
    这里的相等是次序和元素的完全相等，和数组相等是同一个标准，可以参考Arrays.equals()，而和List的标准不一样，可以参考CollectionUtils.isEqualCollection()。
    同理，equalsIgnoreCase()也是同样的实现方式，只是比较字符的时候IgnoreCase。

public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String) anObject;int n = count;if (n == anotherString.count) {char v1[] = value;char v2[] = anotherString.value;int i = offset;int j = anotherString.offset;while (n-- != 0) {if (v1[i++] != v2[j++])return false;}return true;}}return false;}

类似的，compareTo也是逐个比较字符的大小，这里顺序比较，只要找到不相等的元素，返回两者之差即可。这里比较的是两个字符的Unicode，所以两者的差为Unicode之差，如果相等，则返回0，大于返回>0，小于返回<0。
这里的compareTo()是大小写敏感的，不敏感可以用compareToIgnoreCase()，实现原理大抵相同。

public int compareTo(String anotherString) {int len1 = count;int len2 = anotherString.count;int n = Math.min(len1, len2);    // 取最短的，此处只要找不等char v1[] = value;char v2[] = anotherString.value;int i = offset;int j = anotherString.offset;if (i == j) {int k = i;int lim = n + i;while (k < lim) {char c1 = v1[k];char c2 = v2[k];if (c1 != c2) {return c1 - c2;}k++;}} else {while (n-- != 0) {char c1 = v1[i++];char c2 = v2[j++];if (c1 != c2) {return c1 - c2;}}}return len1 - len2;}

indexof

String中的indexof()是判断目标是否存在String中，并定位。
下面看看经典的定位字符串indexof(String str)：
在source[offset+fromIndex]到source[offset+count]中，寻找target [offset]至target [offset+count]的字串。
① 先找到first的位置（循环过滤不同）
② 然后再找到end的位置（循环过滤相同）
③ 判断end-first是否为target.len，相等即找到，返回first-offset；
否则循环①②③。

        static int indexOf(char[] source, int sourceOffset, int sourceCount,char[] target, int targetOffset, int targetCount, int 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) {return i - sourceOffset;    /* Found whole string. */}}}return -1;}

校验String是否以prefix为开始，就是找出String前和prefix一样长度的字串，然后通过equals的逻辑来校验是否相等。

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

另外，判断是否以suffix结尾，也是同样的一个逻辑，(count - suffix.count)截取和suffix一样长度的字串，然后判断equals。

replace

replace()用于覆盖原来的字串，替换成新的。就是先找到源字符(串)，然后再替换。
这里先讨论字符替换的，比较简单，查找方便，替换的时候也不用重新创建char数组，因为长度不变。而字符串的replace()是直接调用正则来匹配替换的，这里就不讨论了。

public String replace(char oldChar, char newChar) {if (oldChar != newChar) {int len = count;int i = -1;char[] val = value;       /* avoid getfield opcode */int off = offset;          /* avoid getfield opcode */while (++i < len)   if (val[off + i] == oldChar) break;if (i < len) {char buf[] = new char[len];for (int j = 0; j < i; j++) {buf[j] = val[off + j];}while (i < len) {char c = val[off + i];buf[i] = (c == oldChar) ? newChar : c;i++;}return new String(0, len, buf);}}return this;}

    如上，先找到oldChar的位置i，break掉，再把i前的字符放到新的数组中，把i处字符换成新的字符，最后再对i后的赋值。
    这里先找到oldChar再替换的方式，还可以用另外两种来处理： 1、全部的if相等就替换；2、先Arrays.copy()再替换。
    而这里的优点在于：如果找不到oldChar，不用新建char[]和String。