java中String、StringBuilder和StringBuffer理解

String、StringBuilder和StringBuffer理解

1>String

java.lang.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

/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;

/**
* Class String is special cased within the Serialization Stream Protocol.
*
* A String instance is written initially into an ObjectOutputStream in the
* following format:
* <pre>
*      <code>TC_STRING</code> (utf String)
* </pre>
* The String is written by method <code>DataOutput.writeUTF</code>.
* A new handle is generated to  refer to all future references to the
* string instance within the stream.
*/
private static final ObjectStreamField[] serialPersistentFields =
new ObjectStreamField[0];
　　......

从以上JDK中String源码可以看出，String类被final修饰，在java中被final修饰的类是不能够被继承的，而且String类中的成员变量都被修饰成final。

而且可以看出String是通过char数组来实现保存字符串的。

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

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

以上是String类的部分成员方法，可以看出他们都不是在原有的String对象上操作的。只要对String对象进行改变，则就会创建新的String对象，对原有的对象并没有改变。

注意：String str1="abc" 和 String str2=new String("abc");有什么区别呢？ 代码测试为证：

public class stringTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
String str1 = "abc";
String str2 = new String("abc");
String str3 = new String("abc");
String str4 = "abc";

System.out.println(str1 == str2);
System.out.println(str2 == str3);
System.out.println(str1 == str4);
}
}

结果是：



所以：string str1="abc"; 这样的语句是在编译时生成了字面常量和字符引用，然后在运行时蒋"abc"保存放到了运行时的常量池中，当下一个语句执行的时候就会从运行时常量池中查找 是否存在，如果存在则将他的引用指向了字面常量，如果没有就新开辟一个空间存放字面常量，并将引用指向他。

　　有关new语句创建对象时，都是在堆中进行的，不会检查对象是否存在，所以每一个new语句都会创建一个新的对象。

2>StringBuilder

StringBuilder对String的改变操作是对原有对象进行操作的。

3>StringBuffer （线程安全）

StringBuffer和StringBuilder是类似的，之不过StringBuffer下的方法被snychronized修饰，线程安全。

这三个类是各有利弊，应当根据不同的情况来进行选择使用：

当字符串相加操作或者改动较少的情况下，建议使用 String str="hello"这种形式；

当字符串相加操作较多的情况下，建议使用StringBuilder，如果采用了多线程，则使用StringBuffer。