String类的定义:
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
}
可以看到String类被final修饰,因此不能被继承。String类还实现了序列化接口Serializable、可比较的接口Comparable并指定范型为String,该接口必须要实现int compareTo(T o) 方法。最后还实现了字符序列CharSequence接口,该接口也有些常用的方法,如charAt(int index)
、length()、toString() 等
String类放的无参构造函数
public String() {
this.value = "".value;
}
其中value定义:
private final char value[];
该构造函数创建了一个空的字符串并存在字符数组value中;
String有参的构造函数:
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
该构造函数指定一个字符数组来创建一个字符序列。是通过Arrays的copyOf方法将字符数组拷贝到当前数组;
这样当修改字符数组的子串时,不会影响新字符数组;
经过以上分析可以看出,下面两个语句是等价的,因为String类底层使用char[]数组来存储字符序列:
char date []= {'a','b','c'}
String str = new String(data);
String的charAt方法:
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
该方法返回字符序列中下标为index的字符。并且index的范围:(0,value.length].
String的contains方法
public boolean contains(CharSequence s) {
return indexOf(s.toString()) > -1;
}
直接调用了indexOf(String str)方法:
public int indexOf(String str) {
return indexOf(str, 0);
}
又调用了 indexOf(str, int)方法:
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) {
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;
}
首先判断开始索引如果大于源字符串则返回,若目标字符串长度为0返回源字符串长度,否则返回-1;
然后迭代查找字符,若全部源字符串都找到则返回第一个匹配的索引,否则返回-1;
所以在public boolean contains(CharSequence s)方法中,若indexOf方法返回-1则返回false,否则返回true;
String的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;
}
该方法首先判断this == anObject ?,也就是说判断要比较的对象和当前对象是不是同一个对象,如果是直接返回true,如不是再继续比较,然后在判断anObject是不是String类型的,如果不是,直接返回false,如果是再继续比较,到了能终于比较字符数组的时候,他还是先比较了两个数组的长度,不一样直接返回false,一样再逐一比较值
hashCode()方法算法分析
/** The value is used for character storage. */
private final char value[]; //将字符串截成的字符数组
/** Cache the hash code for the string */
private int hash; // Default to 0 用以缓存计算出的hashcode值
/**
* Returns a hash code for this string. The hash code for a
* {@code String} object is computed as
* <blockquote><pre>
* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
* </pre></blockquote>
* using {@code int} arithmetic, where {@code s[i]} is the
* <i>i</i>th character of the string, {@code n} is the length of
* the string, and {@code ^} indicates exponentiation.
* (The hash value of the empty string is zero.)
*
* @return a hash code value for this object.
*/
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 X = “abcd”; // 此时value[] = {‘a’,‘b’,‘c’,‘d’} 因此
for循环会执行4次
第一次:h = 31*0 + a = 97
第二次:h = 31*97 + b = 3105
第三次:h = 31*3105 + c = 96354
第四次:h = 31*96354 + d = 2987074
由以上代码计算可以算出 X的hashcode = 2987074 刚好与 System.err.println(new String("abcd").hashCode());
相等
在源码的hashcode的注释中还提供了一个多项式计算方式:
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
s[0] :表示字符串中指定下标的字符
n:表示字符串中字符长度
a*31^3 + b*31^2 + c*31^1 + d = 2987074 + 94178 + 3069 + 100 = 2987074 ;