读 String原代码
1. CharSequence接口定义了一个只读的char序列。String 实现 CharSequence , Serializable , Comaprable<String>
2. 由 char[] value, int offset, int count 和 int hash组成。
3. 构造函数 public String(String original) 基本上来说是没用的，因为String本身是immutable的，没必要copy一下。但有一个用处：节省空间。比如说，你用subString生成的一个String，它是重用原来的char[]的，而原来的那个String你已经不想用了（这个条件很重要）， 你可以用这个构造函数重建一个String来释放空间。
public String(String original) {
int size = original.count;
char[] originalValue = original.value;
char[] v;
if (originalValue.length > size) {
// The array representing the String is bigger than the new
// String itself. Perhaps this constructor is being called
// in order to trim the baggage, so make a copy of the array.
int off = original.offset;
v = Arrays.copyOfRange(originalValue, off, off+size);
} else {
// The array representing the String is the same
// size as the String, so no point in making a copy.
v = originalValue;
}
this.offset = 0;
this.count = size;
this.value = v;
}
4. 提供了一组构造函数，按照给定的Charset来将一个byte 数组 decode成一个字符串。
5. 接收StringBuilder或StringBuffer的构造函数，会将StringBuilder或StringBuffer先toString() 然后将新生成的String中的value , offset 和count赋值给当前String，这时会将char array拷贝一份，所以之后StringBuilder或StringBuffer的修改不会影响到生成的String。但问题是这样不就多生成了一个String对象么？
6. length()返回的是count的值，也就是说是Code Unit的个数，而不是Code Point的个数， 对于Supplementary Character这个length()不是字符个数。如果想得到Code Point的个数可以使用codePointCount方法。
7. getBytes方法，当不传Charset时就用系统默认的Charset将字符串转成相应的编码。
8. public boolean contentEquals(StringBuffer sb) 对 sb作了同步，防止sb中途被修改：
public boolean contentEquals(StringBuffer sb) {
synchronized(sb) {
return contentEquals((CharSequence)sb);
}
}
9. public boolean contentEquals(CharSequence cs) 对StringBuilder和StringBuffer做了特殊处理，这样就避免在调用StringBuilder或StringBUffer的charAt方法时做的边界检查了：
public boolean contentEquals(CharSequence cs) {
if (count != cs.length())
return false;
// Argument is a StringBuffer, StringBuilder
if (cs instanceof AbstractStringBuilder) {
char v1[] = value;
char v2[] = ((AbstractStringBuilder)cs).getValue();
int i = offset;
int j = 0;
int n = count;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
// Argument is a String
if (cs.equals(this))
return true;
// Argument is a generic CharSequence
char v1[] = value;
int i = offset;
int j = 0;
int n = count;
while (n-- != 0) {
if (v1[i++] != cs.charAt(j++))
return false;
}
return true;
}
10. 当作Case Insensitve比较时代价有点高:
public boolean regionMatches(boolean ignoreCase, int toffset,
String other, int ooffset, int len) {
char ta[] = value;
int to = offset + toffset;
char pa[] = other.value;
int po = other.offset + ooffset;
// Note: toffset, ooffset, or len might be near -1>>>1.
if ((ooffset < 0) || (toffset < 0) || (toffset > (long)count - len) ||
(ooffset > (long)other.count - 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;
}
11. hashCode的计算：
public int hashCode() {
int h = hash;
if (h == 0 && count > 0) {
int off = offset;
char val[] = value;
int len = count;
for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;
}
return h;
}
12. String, StringBuilder和StringBuffer 共享了一段indexOf的逻辑：
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;
}
由此可见，想让indexOf(String substr, int fromIndex) 返回String.length()的唯一方法是, fromIndex >= String.length()，并且子串为空串。
13. lastIndexOf写得有点奇怪：
static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount,
int fromIndex) {
/*
* Check arguments; return immediately where possible. For
* consistency, don't check for null str.
*/
int rightIndex = sourceCount - targetCount;
if (fromIndex < 0) {
return -1;
}
if (fromIndex > rightIndex) {
fromIndex = rightIndex;
}
/* Empty string always matches. */
if (targetCount == 0) {
return fromIndex;
}
int strLastIndex = targetOffset + targetCount - 1;
char strLastChar = target[strLastIndex];
int min = sourceOffset + targetCount - 1;
int i = min + fromIndex;
startSearchForLastChar:
while (true) {
while (i >= min && source[i] != strLastChar) {
i--;
}
if (i < min) {
return -1;
}
int j = i - 1;
int start = j - (targetCount - 1);
int k = strLastIndex - 1;
while (j > start) {
if (source[j--] != target[k--]) {
i--;
continue startSearchForLastChar;
}
}
return start - sourceOffset + 1;
}
}
不是很理解为什么一定要从最后一个字符开始比较，虽然是last index，但匹配字符串没必要从最后一个字符开始比较，而且还用了一个让人不是很舒服的label。我也试着写了一个，才发现，其实要写得逻辑很严密还是需要费一番周折的：
private static int myLastIndexOf(char[] source, int sourceOffset,
int sourceCount, char[] target, int targetOffset, int targetCount,
int fromIndex) {
if (fromIndex < 0) {
return -1;
}
int rightIndex = sourceCount - targetCount;
if (fromIndex > rightIndex) {
fromIndex = rightIndex;
}
if (targetCount == 0) {
return fromIndex;
}
char firstChar = target[targetOffset];
int max = targetOffset + targetCount;
for (int i = sourceOffset + fromIndex; i >= sourceOffset; i--) {
if (source[i] != firstChar) {
while (--i >= sourceOffset && source[i] != firstChar)
;
}
if (i >= sourceOffset) {
int j = targetOffset + 1;
for (int k = i + 1; j < max && source[k] == target[j]; k++, j++)
;
if (j == max) {
return i - sourceOffset;
}
}
}
return -1;
}
14. subString重用了原来的char[]。
15. public String replace(CharSequence target, CharSequence replacement) 是纯字面的匹配。replace方法中除了replaceFirst以外都是找出所有匹配的进行替换。
16. trim把比空格小的unicode都当成空白了:
public String trim() {
int len = count;
int st = 0;
int off = offset; /* avoid getfield opcode */
char[] val = value; /* avoid getfield opcode */
while ((st < len) && (val[off + st] <= ' ')) {
st++;
}
while ((st < len) && (val[off + len - 1] <= ' ')) {
len--;
}
return ((st > 0) || (len < count)) ? substring(st, len) : this;
}
17. intern 方法的注释很精确了：
Returns a canonical representation for the string object.
A pool of strings, initially empty, is maintained privately by the class String .
When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.
It follows that for any two strings s and t , s.intern() == t.intern() is true if and only if s.equals(t) is true .
All literal strings and string-valued constant expressions are interned.
17. 最后写了两个test case :
@Test
public void testString() {
String str = new String("ABC");
String str1 = new String("ABC");
assertFalse(str == str1);
assertTrue(str.intern() == str1.intern());
assertEquals(str.length(), str.indexOf("", str.length()));
assertEquals("ss", "\\w\\w".replace((CharSequence)"\\w", "s"));
}