java源码阅读String

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

1类签名与注释

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence

String类被定义为final类型的，所以String对象一旦创建了，就是不可变的。

String类实现了Serializable接口，表示可以序列化。

String类实现了Comparable<String>接口，表示String类型可以相互比较。（通过compareTo方法）

String类实现了CharSequence接口，CharSequence是char值的可读序列。

String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。Strings是不可变的，它们的值在创建后不能被更改。字符串缓冲区支持可变字符串。

Java语言为字符串连接运算符（+）提供特殊支持，并为其他对象转换为字符串。字符串连接是通过StringBuilder （或StringBuffer ）类及其append方法实现的。字符串转换是通过toString方法来实现，该方法定义在Object类中。

2基本属性

private final char value[];private int hash; // Default to 0

String用字符数组存储值，内部还保留了自己的hash值。为什么要将hash值作为成员属性呢？我们先看一下String的hashCode方法

public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value; for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}

当调用String的hashCode方法时，首先会从hash属性取值，当hash属性值为0时（第一次调用该方法），才会重新计算hash值。hash值得计算如line7所示。计算后会将值赋给hash属性。这里保证只在第一次调用hashCode方法的时候计算hash值，之后直接从hash属性取值。这种优化只有当String是final的时候才可以，若String可变的话，hash值也会变化。

3构造方法

String的构造方法有很多，下面是eclipse中outline的所有构造方法的截图。

aaarticlea/png;base64,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" alt="" />

红色方框部分表示废弃方法（我的版本JDK1.8）。通过outline可以看出，String可以通过String、字符数组、int数组、字节数组、StringBuffer/StringBuilder构造。下面贴出几个常用构造方法的代码。

//1构造空String
public String() {
this.value = "".value;
}//2通过String构造
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}//3通过char数组构造
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}//4通过byte数组构造
public String(byte bytes[]) {
this(bytes, 0, bytes.length);
}
public String(byte bytes[], int offset, int length) {
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(bytes, offset, length);
}//5通过字符串缓冲区构造
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

这里有几点自己的理解：

（1）在通过char数组构造的时候，是通过Arrays的copyOf复制了一个新的数组（开辟了新的数组存储空间），这里不是通过简单的引用传递。

（2）byte数组不能直接变成char数组，需要通过StringCoding的decode方法。

（3）注意通过StringBuffer构造的时候加了同步，因为StringBuffer是线程安全的，这里复制的时候加锁也要保证线程安全。

4常用方法

（1）equals方法

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

只有满足类型一样，长度相等，char数组所有的值都相等时equals方法才返回true。

（2）compareTo方法

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

挨个比较字符数组的值，当较短的串所有字符都和较长串的相等时返回串的长度差。当compareTo方法的返回值等于0时，表示被比较的字符串和当前字符串相等，返回值大于0时表示当前字符串较大，返回值小于0表示当前字符串较小。

（3）startsWith和endsWith

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

starsWhith方法是从偏移量开始，挨个比较自身字符数组的值和参数对应的字符数组的值。endsWith用长度差当作偏移量。

（4）indexOf（String）方法

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,
String target, int fromIndex) {
return indexOf(source, sourceOffset, sourceCount,
target.value, 0, target.value.length,
fromIndex);
} 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;
}

主要实现在line17-53，这里就是挨个对比匹配。通过indexOf(String str)调用line17的方法是没有什么问题，因为sourceOffset偏移量总是为0，但是看源码的时候总感觉max（line31）的逻辑会导致数组越界问题。举个例子如下：

public class Test { public static void main(String[] args) { String a = "abc1234";
char[] aa = {'a','b','c','1','2','3','4'};
String b = "25";
char[] bb = {'2','5'};
System.out.println(indexOf(aa,2,aa.length,
bb,0,bb.length,0)); } static int indexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount,
int fromIndex) {
//省略...
}}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 7
at com.ouym.test.Test.indexOf(Test.java:44)
at com.ouym.test.Test.main(Test.java:19)

(5)substring

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

String的subString方法是通过构造方法String(value, beginIndex, subLen)来实现的，截取的字串包含beginIndex，不包含endIndex。举个例子

String a = "0123456";
System.out.println(a.substring(2,4));输出：23

（6）concat

public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
//新建字符数组buf，并将主调String对象的value数组复制到buf
char buf[] = Arrays.copyOf(value, len + otherLen);
//将参数str的字符数组填充到buf的剩余空间
str.getChars(buf, len);
return new String(buf, true);
}

（7）replace

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