String
接口和属性
String类是final不可继承的,用来存放字符数组的value[]也是final修饰的,这意味着String类是不可变的,一旦new出来就不能发生改变。因此对一个String类的对象进行任何修改(增加、删除、替换)之后,都会生成一个新的对象返回。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** 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
}
构造方法
一般直接使用双引号的方式,默认调用构造方法生成一个String对象。构造方法很多,下面只列出常用的几种:
// 默认无参构造
public String() {
this.value = "".value;
}
// 由一个String对象构造 String str = new String("hello");
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
// 字符数组构造
public String(char value[]);
// 字符数组构造,指定偏移量和字符数目
public String(char value[], int offset, int count);
// Unicode码数组构造,指定偏移量和字符数目
public String(int[] codePoints, int offset, int count);
// 字节数组构造
public String(byte bytes[]);
// 字节数组构造,指定偏移量、数目,默认字符集
public String(byte bytes[], int offset, int length);
// 字节数组构造,指定偏移量、数目、字符集
public String(byte bytes[], int offset, int length, Charset charset);
// StringBuffer 构造,线程安全
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
// StringBuilder 构造,非线程安全
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
常用方法
equals()和hashCode()
在涉及到比较和排序时,一般的类都需要同时重写equals()和hashCode()方法。String提供了hashCode()方法实现的模板,需要考虑String类中value字符数组中的每一个字符,将计算出的hash(int)缓存在属性hash中。
equals()
public boolean equals(Object anObject) {
// 注意!equals方法需要满足自反性、对称性、传递性
// 首先就要与自身先判断
if (this == anObject) {
return true;
}
if (anObject instanceof String) { // 使用instanceof,如果不是,直接返回false
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;
}
hashCode()
// 计算String的int类型hash码
// hash = s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[0]
/* 根据Effective Java第9条中的描述
使用31是因为31是奇数素数,习惯上都使用素数来计算散列结果。
使用31可以用移位运算和减法代替乘法,提高效率:
31 * i == (i << 5) - i
现代的虚拟机VM都会自动完成这种优化。
*/
public int hashCode() {
int h = hash; // hash缓存,初始为0
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;
}
length()、isEmpty()、charAt()
String的length()是方法,而数组的length是属性,注意二者的区分。此外与C/C++中的字符串不同,C/C++的字符串一定是以’\0’结尾,length包括了这一个结束符,而Java中的String类中的value字符数组没有该结束符。
// 字符串长度
public int length() {
return value.length;
}
public boolean isEmpty() {
return value.length == 0;
}
// 第index位置的字符
public char charAt(int index) {
// 注意!索引范围检查
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
equalsIgnoreCase()
忽略大小写的字符串比较。技巧:注意三目条件运算符和逻辑运算的使用,能够有效避免冗长的if…else…语句,使代码简洁清晰。
public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true
: (anotherString != null)
&& (anotherString.value.length == value.length)
&& regionMatches(true, 0, anotherString, 0, value.length);
}
indexOf()
获取某则字符或者字符串在当前字符串中首次出现的索引。技巧:代码的重用。
// 或者字符ch(Unicode码形式)首次出现的索引
public int indexOf(int ch, int fromIndex) {
final int max = value.length;
if (fromIndex < 0) {
fromIndex = 0;
} else if (fromIndex >= max) {
// Note: fromIndex might be near -1>>>1.
return -1;
}
if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
// handle most cases here (ch is a BMP code point or a
// negative value (invalid code point))
final char[] value = this.value;
for (int i = fromIndex; i < max; i++) {
if (value[i] == ch) {
return i;
}
}
return -1;
} else {
return indexOfSupplementary(ch, fromIndex);
}
}
// 代码重用
public int indexOf(int ch) {
return indexOf(ch, 0);
}
/**
* Code shared by String and StringBuffer to do searches. The
* source is the character array being searched, and the target
* is the string being searched for.
*
* @param source the characters being searched.
* @param sourceOffset offset of the source string.
* @param sourceCount count of the source string.
* @param target the characters being searched for.
* @param targetOffset offset of the target string.
* @param targetCount count of the target string.
* @param fromIndex the index to begin searching from.
*/
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;
}
// 字符串首次出现的索引,从fromIndex位置开始搜索
public int indexOf(String str, int fromIndex) {
return indexOf(value, 0, value.length,
str.value, 0, str.value.length, fromIndex);
}
// 字符串首次出现的索引,代码重用
public int indexOf(String str) {
return indexOf(str, 0);
}
replace()
替换字符或字符序列,生成新的String对象返回。
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;
}
// 替换字符序列
public String replace(CharSequence target, CharSequence replacement) {
return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}
substring()
利用构造函数取子串。技巧:索引范围检查和代码重用。
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);
}
trim()
去除首尾空格
public String trim() {
int len = value.length;
int st = 0;
char[] val = value; /* avoid getfield opcode */
// 首部空格跳过
while ((st < len) && (val[st] <= ' ')) {
st++;
}
// 尾部空格跳过
while ((st < len) && (val[len - 1] <= ' ')) {
len--;
}
// 取子串,代码重用
return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}
getChars()
从字符串读入数据到字符数组,注意,该方法没有进行索引边界检查。
/**
* Copy characters from this string into dst starting at dstBegin.
* This method doesn't perform any range checking.
*/
void getChars(char dst[], int dstBegin) {
System.arraycopy(value, 0, dst, dstBegin, value.length);
}
concat()
连接字符串。技巧:代码重用。
//Concatenates the specified string to the end of this string.
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len); // 代码重用,从字符串读取数组到字符数组
return new String(buf, true); // 构造新的String对象返回
}
toCharArray()
将字符串转为字符数组。
public char[] toCharArray() {
// Cannot use Arrays.copyOf because of class initialization order issues
char result[] = new char[value.length];
System.arraycopy(value, 0, result, 0, value.length);
return result;
}
valueOf()
由boolean、char、double、int、float、long等基础类型生成String(利用包装类的toString()方法。由字符数组生成String(利用String构造函数)。将object转换为String,比obj+”“和obj.toString()都好,因为从源码中可以看出,valueOf()很好的避免了空指针异常。
public static String valueOf(char data[]) {
return new String(data);
}
public static String valueOf(int i) {
return Integer.toString(i);
}
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
......
copyValueOf(char[])
类似于构造函数,使用char数组生成String。
public static String copyValueOf(char data[]) {
return new String(data);
}
startWith()、endWith()
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;
}
// 代码重用
public boolean startsWith(String prefix) {
return startsWith(prefix, 0);
}
// 代码重用
public boolean endsWith(String suffix) {
return startsWith(suffix, value.length - suffix.value.length);
}
StringBuilder
上面提到String是不可变的对象,任何对String对象的修改最后都会返回一个全新的String对象。如果需要对字符串进行大量的修改时,可以考虑使用StringBuilder,StringBuilder继承自AbstractStringBuilder,而AbstractStringBuilder实现了Appendable接口和CharSequence接口。因此如果对StringBuilder对象进行修改,会将对象中的value[]字符数组进行扩容,之后将添加的新的字符序列添加到value[]的尾部。返回原来的对象。
对字符序列的修改,最主要的是append()和insert(),有很多重载形式。
以append(String str)为例,StringBuilder的append直接调用基类AbstractStringBuilder的append(String str)方法:
public StringBuilder append(String str) {
super.append(str);
return this;
}
基类AbstractStringBuilder的append(String str)方法首先对value[]数组进行扩容,之后调用String.getChars()方法,将添加的新值拷贝到value[]数组中。
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len); // value[]数组扩容
str.getChars(0, len, value, count); // 将添加的新值拷贝到value[]数组
count += len; // 更新字符的数目
return this; // 返回同一个StringBuilder对象
}
String.getChars()方法:主要包括索引边界检查和拷贝数组两个步骤。
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
if (srcBegin < 0) {
throw new StringIndexOutOfBoundsException(srcBegin);
}
if (srcEnd > value.length) {
throw new StringIndexOutOfBoundsException(srcEnd);
}
if (srcBegin > srcEnd) {
throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
}
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}
注意:StringBuilder的构造函数中指定value[]数组的默认长度为16,即默认能够存储16个字符,如果超过16,则进行自动扩容,由于扩容一页带来一定的开销,如果能够预估最后字符序列的长度,使用重载的构造函数StringBuilder(int capacity)能够有效减小扩容开销,提高效率。另外,StringBuilder不是线程安全的。
StringBuffer
StringBuffer是StringBuilder的同步版本,所有的append()和insert()方法都使用synchronized关键字进行了锁定,是线程安全的。由于加锁互斥会带来很大的开销,如果不需要考虑多线程同时修改字符串的情况,推荐使用StringBuilder,既不会产生过多的对象,也不会因为需要加锁而产生很大的开销。