String 和StringBuffer StringBuild 的区别：

String 和StringBuffer StringBuild 的区别：

String是不可改变，定长；

StringBuffer是不定长，可改变，通过分配更大的内存实现，StringBuffer是线程安全的可变字符序列。可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步。

StringBuilder是单个线程使用的StringBuffer等价类，一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

在 StringBuilder 上的主要操作是 append 和 insert 方法， append 方法始终将这些字符添加到生成器的末端；而 insert 方法则在指定的点添加字符。将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。

注意：本来以为StringBuilder和StringBuffer的equals方法是可以比较两个字符串的内容是否相等，今天才发现不是这么回事。这两个类都直接继承自Object，并且没有重写equals方法。

StringBuilder sb1 = new StringBuilder("123");

StringBuilder sb2 = new StringBuilder("123");

System.out.println(sb1.equals(sb2));

输出结果是：false

若要比较内容是否相同，sb1.toString().equals(sb2.toString())

比较：

StringBuffer str = new StringBuffer("a");

str.append("bc");

String str2 = "a";

str2 = str2 + "bc";

str引用的一直是同一对象；而str2引用的在两句中是完全不同的对象。

Java的StringBuffer类

（1）构造方法：

a. StringBuffer s0=new StringBuffer();分配了长16字节的字符缓冲区

c. StringBuffer s2=new StringBuffer("You are good!"); 在字符缓冲区中存放字符串"Happy new year！"，另外，后面再留了16字节的空缓冲区。

（2） 常用方法：

a．字符设置和替换

setCharAt(int index,char ch),将指定的字符ch放到index指出的位置。

charAt(int index) 获得指定位置的字符

例如： s="stedent";

s.setCharAt(2,"u"),则s为"student"

b.字符的插入

insert(int offset,char ch),在offset位置插入字符ch。

例如：StringBuffer s=new StringBuffer("wecome");

s.insert(2,'l'),则s为"welcome"

c．在字符串末尾添加内容（Append方法）

StringBuffer s=newStringBuffer("we");

char d={"l","c","o","m","e"};

s.append(d);则s为"welcome"。

d.转换为不变字符串:toString()。

StringBuffer sb=new StringBuffer("How are you?");

Label l1=new Label(sb.toString());

e.获取字符串的长度: length()

StringBuffer s = new StringBuffer("www");

int i=s.length();

j.字符串反转 s.reverse();

k.删除指定字符串着中的字符

delete(int start,int end)

s.delete(0,s.length()); //删除字符串s的全部字符

deleteCharAt(int index)

s.deleteCharAt(4); //删除字符串s索引为4的字符

l.替换字符串

replace(int start,int end,String str)

s.replace(0,1,"qqq");

m.返回字符串的一部分值

substring(int start) //返回从start下标开始以后的字符串

substring(int start,int end) //返回从start到 end-1字符串

public class TestStringBuffer {

public static void main(String args[]) {

String s = "dengkehai" ;

char[] a = {'a','b','c'} ;

StringBuffer sb1 = new StringBuffer(s) ;

sb1.append('/').append("DKH").append('/').append("J2SE") ;

System.out.println(sb1) ;

StringBuffer sb2 = new StringBuffer("Number:") ;

for(int i=0 ;i<10 ;i++)

sb2.append(i) ;

System.out.println(sb2) ;

sb2.delete(10,sb2.length()).insert(0,a) ;

System.out.println(sb2) ;

System.out.println(sb2.reverse()) ;

}

}//结果：

dengkehai/DKH/J2SE

Number:0123456789

abcNumber:012

210:rebmuNcba

String 是不可变的, 因为String的内存分配方式跟数组的一样，都是静态分配的。 例如：一个String s = "abc"; s = s + 1;在这里试图去改变s的值，但是实际上s = s + 1;是开辟了例外一个内存。s 的值还是没变。 String 里面的方法是异步的。 StringBuffer 的方法是同步的。StringBuild的方法是异步的。异步的性能要高，同步的安全性高。

在java中有3个类来负责字符的操作。

1.character 是进行单个字符操作的，

2.string 对一串字符进行操作。不可变类。

3.stringbuffer 也是对一串字符进行操作，但是可变类。

string: 是对象不是原始类型. 为不可变对象,一旦被创建,就不能修改它的值. 对于已经存在的string对象的修改都是重新创建一个新的对象,然后把新的值保存进去. string 是final类,即不能被继承.

stringbuffer: 是一个可变对象,当对他进行修改的时候不会像string那样重新建立对象 它只能通过构造函数来建立, stringbuffer sb = new stringbuffer(); note:不能通过付值符号对他进行付值. sb = "welcome to here!";//error 对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向stringbuffer 中付值的时候可以通过它的append方法. sb.append("hello");

字符串连接操作中stringbuffer的效率要比string高:

string str = new string("welcome to "); str += "here"; 的处理步骤实际上是通过建立一个stringbuffer,让侯调用append(),最后 再将stringbuffer tosting(); 这样的话string的连接操作就比stringbuffer多出了一些附加操作,当然效率上要打折扣.

并且由于string 对象是不可变对象,每次操作sting 都会重新建立新的对象来保存新的值. 这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.

看看以下代码： 将26个英文字母重复加了5000次，

    string tempstr = "abcdefghijklmnopqrstuvwxyz";     int times = 5000;     long lstart1 = system.currenttimemillis();     string str = "";     for (int i = 0; i < times; i++) {     str += tempstr;     }     long lend1 = system.currenttimemillis();     long time = (lend1 - lstart1);     system.out.println(time); 可惜我的计算机不是超级计算机，得到的结果每次不一定一样一般为 46687左右。 也就是46秒。 我们再看看以下代码

    string tempstr = "abcdefghijklmnopqrstuvwxyz";     int times = 5000;     long lstart2 = system.currenttimemillis();     stringbuffer sb = new stringbuffer();     for (int i = 0; i < times; i++) {     sb.append(tempstr);     }     long lend2 = system.currenttimemillis();     long time2 = (lend2 - lstart2);     system.out.println(time2); 得到的结果为 16 有时还是 0 所以结论很明显，stringbuffer 的速度几乎是string 上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候，差异更大。不信你试试。

根据上面所说：

str += "here"; 的处理步骤实际上是通过建立一个stringbuffer,让侯调用append(),最后 再将stringbuffer tosting();

所以str += "here";可以等同于

stringbuffer sb = new stringbuffer(str);

sb.append("here");

str = sb.tostring();

所以上面直接利用"+"来连接string的代码可以基本等同于以下代码

    string tempstr = "abcdefghijklmnopqrstuvwxyz";     int times = 5000;     long lstart2 = system.currenttimemillis();     string str = "";     for (int i = 0; i < times; i++) {     stringbuffer sb = new stringbuffer(str);     sb.append(tempstr);     str = sb.tostring();     }     long lend2 = system.currenttimemillis();     long time2 = (lend2 - lstart2);     system.out.println(time2); 平均执行时间为46922左右，也就是46秒。

总结: 如果在程序中需要对字符串进行频繁的修改连接操作的话.使用stringbuffer性能会更高

本文来自csdn博客，转载请标明出处： http://blog.csdn.net/yirentianran/archive/2008/09/03/2871417.aspx