String 和 StringBuffer区别
JAVA平台提供了两个类:String和StringBuffer,它们可以储存和操作字符串,即包含多个字符的字符数据.这个String类提供了数值不可改变的字符串.而这个StringBuffer类提供的字符串进行修改.当你知道字符数据要改变的时候你就可以使用 StringBuffer.典型地,你可以使用 StringBuffers来动态构造字符数据.
一、String的使用方法:
因为对象的默认值是null,所以String的默认值也是null;但它又是一种特殊的对象,有其它对象没有的一些特性.
public class Test {
public static void main(String [] args) {
String s0="java";
String s1="java";
String s2="ja" + "va";
System.out.println( s0==s1 );
System.out.println( s0==s2 );
}
}
true
true
因为例子中的s0和s1中的"java"都是字符串常量,它们在编译期就被确定了,所以s0==s1为true;而"ja"和"va"也都是字符串常量,当一个字符串由多个字符串常量连接而成时,它自己肯定也是字符串常量,所以s2也同样在编译期就被解析为一个字符串常量,所以s2也是常量池中"java"的一个引用.
所以我们得出s0==s1==s2;
public class Test {
public static void main(String [] args) {
String s0="java";
String s1=new String("java");
String s2="ja" + new String("va");
System.out.println( s0==s1 );
System.out.println( s0==s2 );
System.out.println( s1==s2 );
}
}
false
false
false
这个对于String简单来说就是比较两字符串的Unicode序列是否相当,如果相等返回true;而==是比较两字符串的地址是否相同,也就是是否是同一个字符串的引用。
二、Java StringBuffer的使用方法:
2.StringBuffer和String类似,但StringBuffer可以对其字符串进行改变;
3.StringBuffer类的常见构造方法:
StringBuffer()
创建一个不包含字符序列的"空"的StringBuffer对象;
StringBuffer(String str)
创建一个StringBuffer对象,包含与String对象str相同的字符序列.
4.常用方法:
public StringBuffer append()
可以为该StringBuffer对象添加字符序列,返回添加后的该StringBuffer对象引用;
public StringBuffer insert()
可以为该StringBuffer对象在指定位置插入字符序列,返回修改后的该
三、String 与StringBuffer的区别
1. String:在String类中没有用来改变已有字符串中的某个字符的方法，由于不能改变一个java字符串中的某个单独字符，所以在JDK文档中称String类的对象是不可改变的。然而，不可改变的字符串具有一个很大的优点:编译器可以把字符串设为共享的。
2.StringBuffer:StringBuffer类属于一种辅助类，可预先分配指定长度的内存块建立一个字符串缓冲区。
这样使用StringBuffer类的append方法追加字符 比 String使用 + 操作符添加字符 到 一个已经存在的字符串后面有效率得多。
因为使用 + 操作符每一次将字符添加到一个字符串中去时，字符串对象都需要寻找一个新的内存空间来容纳更大的字符串，这无凝是一个非常消耗时间的操作。添加多个字符也就意味着要一次又一次的对字符串重新分配内存。使用StringBuffer类就避免了这个问题.
3.String 字符串常量
StringBuffer 字符串变量（线程安全）
简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象,
因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，
然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，
因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。
所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。
而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
String S1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。
其实这是 JVM 的一个把戏，在 JVM 眼里，这个 String S1 = “This is only a” + “ simple” + “test”;
其实就是： String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。
但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，
譬如：String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做。
public class Test {
public static void stringReplace(String text) {
//把textString的地址copy给text
//在这个类中相当于又新new出一个text的对象，新对象text指向java
//text.replace('j', 'i');的结果是"iava"
text = text.replace('j', 'i');
//输出结果为新对象中的值iava
System.out.println (text);
}
public static void bufferReplace(StringBuffer text) {
//textBuffer的地址copy给text
//然后沿着text指向的字符串(其实也就是textBuffer指向的对象)操作,添加一个"C"
//与原对象操作的是同一块内存区域
text = text.append("C");
//输出结果为是原来对象改变后的值javac
System.out.println (text);
}
public static void main(String args[]) {
String textString = new String("java");
StringBuffer textBuffer = new StringBuffer("java");
stringReplace(textString);
bufferReplace(textBuffer);
System.out.println(textString + textBuffer);
}
}
输出：
iava
javajavaC