JAVA中String与StringBuffer的区别 .

String和StringBuffer的区别,网上资料可以说是数不胜数,但是看到这篇文章,感觉里面做的小例子很有代表性,所以转一下,并自己做了一点总结。

 

在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次,

01.        String tempstr = "abcdefghijklmnopqrstuvwxyz";
02.        int times = 5000;
03.        long lstart1 = System.currentTimeMillis();
04.        String str = "";
05.        for (int i = 0; i < times; i++) {
06.            str += tempstr;
07.        }
08.        long lend1 = System.currentTimeMillis();
09.        long time = (lend1 - lstart1);
10.        System.out.println(time);
可惜我的计算机不是超级计算机,得到的结果每次不一定一样一般为 46687左右。
也就是46秒。
我们再看看以下代码

01.        String tempstr = "abcdefghijklmnopqrstuvwxyz";
02.        int times = 5000;
03.        long lstart2 = System.currentTimeMillis();
04.        StringBuffer sb = new StringBuffer();
05.        for (int i = 0; i < times; i++) {
06.            sb.append(tempstr);
07.        }
08.        long lend2 = System.currentTimeMillis();
09.        long time2 = (lend2 - lstart2);
10.        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的代码可以基本等同于以下代码

01.        String tempstr = "abcdefghijklmnopqrstuvwxyz";
02.        int times = 5000;
03.        long lstart2 = System.currentTimeMillis();
04.        String str = "";
05.        for (int i = 0; i < times; i++) {
06.            StringBuffer sb = new StringBuffer(str);
07.            sb.append(tempstr);
08.            str = sb.toString();
09.        }
10.        long lend2 = System.currentTimeMillis();
11.        long time2 = (lend2 - lstart2);
12.        System.out.println(time2);
平均执行时间为46922左右,也就是46秒。

 

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


展开阅读全文

JAVAStringStringBuffer 、StringBuilder的区别

06-09

String和StringBuffer的区别,网上资料可以说是数不胜数,但是看到这篇文章,感觉里面做的小例子很有代表性,所以转一下,并自己做了一点总结。rnrn在java中有3个类来负责字符的操作。rnrn1.Character 是进行单个字符操作的,rnrn2.String 对一串字符进行操作。不可变类。rnrn3.StringBuffer 也是对一串字符进行操作,但是可变类。rnrnString:rn是对象不是原始类型.rn为不可变对象,一旦被创建,就不能修改它的值.rn对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.rnString 是final类,即不能被继承.rnrnStringBuffer:rn是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象rn它只能通过构造函数来建立,rnStringBuffer sb = new StringBuffer();rnnote:不能通过付值符号对他进行付值.rnsb = "welcome to here!";//errorrn对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBufferrn中付值的时候可以通过它的append方法.rnsb.append("hello");rnrn字符串连接操作中StringBuffer的效率要比String高:rnrnString str = new String("welcome to ");rnstr += "here";rn的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后rn再将StringBuffer toSting();rn这样的话String的连接操作就比StringBuffer多出了一些附加操作,当然效率上要打折扣.rnrn并且由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值.rn这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.rnrn看看以下代码:rn将26个英文字母重复加了5000次,rnrn String tempstr = "abcdefghijklmnopqrstuvwxyz";rn int times = 5000;rn long lstart1 = System.currentTimeMillis();rn String str = "";rn for (int i = 0; i < times; i++) rn str += tempstr;rn rn long lend1 = System.currentTimeMillis();rn long time = (lend1 - lstart1);rn System.out.println(time);rn可惜我的计算机不是超级计算机,得到的结果每次不一定一样一般为 46687左右。rn也就是46秒。rn我们再看看以下代码rnrn String tempstr = "abcdefghijklmnopqrstuvwxyz";rn int times = 5000;rn long lstart2 = System.currentTimeMillis();rn StringBuffer sb = new StringBuffer();rn for (int i = 0; i < times; i++) rn sb.append(tempstr);rn rn long lend2 = System.currentTimeMillis();rn long time2 = (lend2 - lstart2);rn System.out.println(time2);rn得到的结果为 16 有时还是 0rn所以结论很明显,StringBuffer 的速度几乎是String 上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候,差异更大。不信你试试。rnrn根据上面所说:rnrnstr += "here";rn的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后rn再将StringBuffer toSting();rnrn所以str += "here";可以等同于rnrnStringBuffer sb = new StringBuffer(str);rnrnsb.append("here");rnrnstr = sb.toString();rnrn所以上面直接利用"+"来连接String的代码可以基本等同于以下代码rnrn String tempstr = "abcdefghijklmnopqrstuvwxyz";rn int times = 5000;rn long lstart2 = System.currentTimeMillis();rn String str = "";rn for (int i = 0; i < times; i++) rn StringBuffer sb = new StringBuffer(str);rn sb.append(tempstr);rn str = sb.toString();rn rn long lend2 = System.currentTimeMillis();rn long time2 = (lend2 - lstart2);rn System.out.println(time2);rn平均执行时间为46922左右,也就是46秒。rnrn本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/yirentianran/archive/2008/09/03/2871417.aspxrnrnStringBuffer维护了一个大小固定的字符串缓冲区,当字符串长度超过StringBuffer大小时会自动增加,主要使用Insert和append方法,对于运行期要进行字符串的组装操作推荐使用,rnrn StringBuilder: jdk5以后有个和StringBuffer等价的StringBuider,区别在于StringBuffer是线程安全的,StringBuilder是单线程的,不提供同步,理论上效率更高。rnrn String是系统内置类型,而且是final的,定义一个字符串会产生一个实例和一个对该实例地址的引用。rnrn 如果在编译期间定义的字符串,例如 :rnrn String a = "name";rn a += "is";rn a += "good";rnrn 尽管这种方法是不被推荐的,但在编译期,编译器会对该代码进行优化,所以还是可以理解为:String a = "name is good";而如果在此时采用StringBuffer,反而会推迟到运行期才会被处理,相比之下,反而会比StringBuffer效率更高,灵活运用。rnString 字符串常量rnStringBuffer 字符串变量(线程安全)rnStringBuilder 字符串变量(非线程安全)rn 简要的说, String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,然后将指针指向新的 String 对象,所以经常改变内容的字符串最好不要用 String ,因为每次生成对象都会对系统性能产生影响,特别当内存中无引用对象多了以后, JVM 的 GC 就会开始工作,那速度是一定会相当慢的。rn 而如果是使用 StringBuffer 类则结果就不一样了,每次结果都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ,特别是字符串对象经常改变的情况下。而在某些特别情况下, String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接,所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢,而特别是以下的字符串对象生成中, String 效率是远要比 StringBuffer 快的:rn String S1 = “This is only a” + “ simple” + “ test”;rn StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);rn 你会很惊讶的发现,生成 String S1 对象的速度简直太快了,而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏,在 JVM 眼里,这个rn String S1 = “This is only a” + “ simple” + “test”; 其实就是:rn String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是,如果你的字符串是来自另外的 String 对象的话,速度就没那么快了,譬如:rnString S2 = “This is only a”;rnString S3 = “ simple”;rnString S4 = “ test”;rnString S1 = S2 +S3 + S4;rn这时候 JVM 会规规矩矩的按照原来的方式去做rnrn在大部分情况下 StringBuffer > StringrnStringBufferrnJava.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区,但不能修改。虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。rn可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步,因此任意特定实例上的所有操作就好像是以串行顺序发生的,该顺序与所涉及的每个线程进行的方法调用顺序一致。rnStringBuffer 上的主要操作是 append 和 insert 方法,可重载这些方法,以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。 append 方法始终将这些字符添加到缓冲区的末端;而 insert 方法则在指定的点添加字符。rn例如,如果 z 引用一个当前内容是“start”的字符串缓冲区对象,则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”,而 z.insert(4, "le") 将更改字符串缓冲区,使之包含“starlet”。rn在大部分情况下 StringBuilder > StringBufferrnjava.lang.StringBuildernjava.lang.StringBuilder 一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API,但不保证同步。该类被设计用作 StringBuffer 的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。如果可能,建议优先采用该类,因为在大多数实现中,它比 StringBuffer 要快。两者的方法基本相同。rn通过非官方试验测试,StringBuilder和StringBuffer的测试总结如下:rnrn1. 为了获得更好的性能,在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。当然,如果你操作的字符串长度不超过 16 个字符就不用了。rnrn2. 相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升,但却要冒多线程不安全的风险。而在现实的模块化编程中,负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行,因此:除非你能确定你的系统的瓶颈是在 StringBuffer 上,并且确定你的模块不会运行在多线程模式下,否则还是用 StringBuffer 吧 Jrnrn3. 用好现有的类比引入新的类更重要。很多程序员在使用 StringBuffer 时是不指定其容量的(至少我见到的情况是这样),如果这样的习惯带入 StringBuilder 的使用中,你将只能获得 10 %左右的性能提升(不要忘了,你可要冒多线程的风险噢);但如果你使用指定容量的 StringBuffer ,你将马上获得 45% 左右的性能提升,甚至比不使用指定容量的 StirngBuilder 都快 30% 左右。rn 论坛

StringStringBuffer的区别

02-20

转自:rnhttp://hi.baidu.com/ishanlin/item/0f7314ec7458efc0baf37d11rnjava面试笔试题:String 和StringBuffer的区别rnrnJAVA平台提供了两个类:String和StringBuffer,它们可以储存和操作字符串,即包含多个字符的字符数据.这个String类提供了数值不可改变的字符串.而这个StringBuffer类提供的字符串进行修改.当你知道字符数据要改变的时候你就可以使用 StringBuffer.典型地,你可以使用 StringBuffers来动态构造字符数据.rnrn Java String的使用方法:rnrn 1. 首先String不属于8种基本数据类型,String是一个对象.rnrn 因为对象的默认值是null,所以String的默认值也是null;但它又是一种特殊的对象,有其它对象没有的一些特性.rnrn 2. new String()和new String("")都是申明一个新的空字符串,是空串不是null;rnrn 3. String str="kvill";rnrn String str=new String ("kvill");的区别:rnrn 在这里,我们不谈堆,也不谈栈,只先简单引入常量池这个简单的概念.rnrn 常量池(constant pool)指的是在编译期被确定,并被保存在已编译的.class文件中的一些数据.它包括了关于类、方法、接口等中的常量,也包括字符串常量.rnrn 看例1:rnrn String s0="kvill";rnrn String s1="kvill";rnrn String s2="kv" + "ill";rnrn System.out.println( s0==s1 );rnrn System.out.println( s0==s2 );rnrn 结果为:rnrn truernrn truernrn 首先,我们要知道Java会确保一个字符串常量只有一个拷贝.rnrn 因为例子中的s0和s1中的"kvill"都是字符串常量,它们在编译期就被确定了,所以s0==s1为true;而"kv"和"ill"也都是字符串常量,当一个字符串由多个字符串常量连接而成时,它自己肯定也是字符串常量,所以s2也同样在编译期就被解析为一个字符串常量,所以s2也是常量池中"kvill"的一个引用.rnrn 所以我们得出s0==s1==s2;rnrn 用new String() 创建的字符串不是常量,不能在编译期就确定,所以new String() 创建的字符串不放入常量池中,它们有自己的地址空间.rnrn 看例2:rnrn String s0="kvill";rnrn String s1=new String("kvill");rnrn String s2="kv" + new String("ill");rnrn System.out.println( s0==s1 );rnrn System.out.println( s0==s2 );rnrn System.out.println( s1==s2 );rnrn 结果为:rnrn falsernrn falsernrn falsernrn 例2中s0还是常量池中"kvill"的应用,s1因为无法在编译期确定,所以是运行时创建的新对象"kvill"的引用,s2因为有后半部分new String("ill")所以也无法在编译期确定,所以也是一个新创建对象"kvill"的应用;明白了这些也就知道为何得出此结果了.rnrn 4. String.intern():rnrn 再补充介绍一点:存在于.class文件中的常量池,在运行期被JVM装载,并且可以扩充.String的intern()方法就是扩充常量池的一个方法;当一个String实例str调用intern()方法时,Java查找常量池中是否有相同Unicode的字符串常量,如果有,则返回其的引用,如果没有,则在常量池中增加一个Unicode等于str的字符串并返回它的引用;看例3就清楚了rnrn 例3:rnrn String s0= "kvill";rnrn String s1=new String("kvill");rnrn String s2=new String("kvill");rnrn System.out.println( s0==s1 );rnrn System.out.println( "**********" );rnrn s1.intern();rnrn s2=s2.intern(); //把常量池中"kvill"的引用赋给s2rnrn System.out.println( s0==s1);rnrn System.out.println( s0==s1.intern() );rnrn System.out.println( s0==s2 );rnrn 结果为:rnrn falsernrn **********rnrn false //虽然执行了s1.intern(),但它的返回值没有赋给s1rnrn true //说明s1.intern()返回的是常量池中"kvill"的引用rnrn truernrn 最后我再破除一个错误的理解:rnrn 有人说,"使用String.intern()方法则可以将一个String类的保存到一个全局String表中,如果具有相同值的Unicode字符串已经在这个表中,那么该方法返回表中已有字符串的地址,如果在表中没有相同值的字符串,则将自己的地址注册到表中"如果我把他说的这个全局的String 表理解为常量池的话,他的最后一句话,"如果在表中没有相同值的字符串,则将自己的地址注册到表中"是错的:rnrn 看例4:rnrn String s1=new String("kvill");rnrn String s2=s1.intern();rnrn System.out.println( s1==s1.intern() );rnrn System.out.println( s1+" "+s2 );rnrn System.out.println( s2==s1.intern() );rnrn 结果:rnrn falsernrn kvill kvillrnrn truernrn 在这个类中我们没有声名一个"kvill"常量,所以常量池中一开始是没有"kvill"的,当我们调用s1.intern()后就在常量池中新添加了一个"kvill"常量,原来的不在常量池中的"kvill"仍然存在,也就不是"将自己的地址注册到常量池中"了.rnrn s1==s1.intern()为false说明原来的"kvill"仍然存在;rnrn s2现在为常量池中"kvill"的地址,所以有s2==s1.intern()为true.rnrn 5. 关于equals()和==:rnrn 这个对于String简单来说就是比较两字符串的Unicode序列是否相当,如果相等返回true;而==是比较两字符串的地址是否相同,也就是是否是同一个字符串的引用.rnrn 6. 关于String是不可变的rnrn 这一说又要说很多,大家只要知道String的实例一旦生成就不会再改变了,比如说:String str="kv"+"ill"+" "+"ans";rnrn 就是有4个字符串常量,首先"kv"和"ill"生成了"kvill"存在内存中,然后"kvill"又和" " 生成 "kvill "存在内存中,最后又和生成了"kvill ans";并把这个字符串的地址赋给了str,就是因为String的"不可变"产生了很多临时变量,这也就是为什么建议用StringBuffer的原因了,因为StringBuffer是可改变的rnrn Java StringBuffer的使用方法:rnrn 1.java.lang.StringBuffer代表可变的字符序列;rnrn 2.StringBuffer和String类似,但StringBuffer可以对其字符串进行改变;rnrn 3.StringBuffer类的常见构造方法:rnrn StringBuffer()rnrn 创建一个不包含字符序列的"空"的StringBuffer对象;rnrn StringBuffer(String str)rnrn 创建一个StringBuffer对象,包含与String对象str相同的字符序列.rnrn 4.常用方法:rnrn public StringBuffer append()rnrn 可以为该StringBuffer对象添加字符序列,返回添加后的该StringBuffer对象引用;rnrn public StringBuffer insert()rnrn 可以为该StringBuffer对象在指定位置插入字符序列,返回修改后的该rnrn [b] public StringBuffer delete(int start,int end)rnrn 可以删除从start开始到end-1为止的一段字符序列,返回修改后的该rnrn public StringBuffer reverse()rnrn 用于将字符序列逆序,返回修改后的该StringBuffer对象引用.rnrn 实例:rnrn 程序代码rnrn public class TestStringBufferrnrn rnrn public static void main(String args[]) rnrn String s = "dengkehai" ;rnrn char[] a = 'a','b','c' ;rnrn StringBuffer sb1 = new StringBuffer(s) ;rnrn sb1.append('/').append("DKH").append('/').append("J2SE") ;rnrn System.out.println(sb1) ;rnrn StringBuffer sb2 = new StringBuffer("Number:") ;rnrn for(int i=0 ;i<10 ;i++)rnrn sb2.append(i) ;rnrn System.out.println(sb2) ;rnrn sb2.delete(10,sb2.length()).insert(0,a) ;rnrn System.out.println(sb2) ;rnrn System.out.println(sb2.reverse()) ;rnrn rnrn rn 论坛

没有更多推荐了,返回首页