`
txf2004
  • 浏览: 6831011 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

String, StringBuffer, StringBuilder的区别

 
阅读更多
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次,



可惜我的计算机不是超级计算机,得到的结果每次不一定一样一般为 46687左右。
也就是46秒。
我们再看看以下代码


得到的结果为 16 有时还是 0
所以结论很明显,StringBuffer 的速度几乎是String 上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候,差异更大。不信你试试。

根据上面所说:

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

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


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


平均执行时间为46922左右,也就是46秒。

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




StringBuffer维护了一个大小固定的字符串缓冲区,当字符串长度超过StringBuffer大小时会自动增加,主要使用Insert和append方法,对于运行期要进行字符串的组装操作推荐使用,

StringBuilder: jdk5以后有个和StringBuffer等价的StringBuider,区别在于StringBuffer是线程安全的,StringBuilder是单线程的,不提供同步,理论上效率更高。

String是系统内置类型,而且是final的,定义一个字符串会产生一个实例和一个对该实例地址的引用。

如果在编译期间定义的字符串,例如 :




尽管这种方法是不被推荐的,但在编译期,编译器会对该代码进行优化,所以还是可以理解为:String a = "name is good";而如果在此时采用StringBuffer,反而会推迟到运行期才会被处理,相比之下,反而会比StringBuffer效率更高,灵活运用。

简要的说, String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,然后将指针指向新的 String 对象,所以经常改变内容的字符串最好不要用 String ,因为每次生成对象都会对系统性能产生影响,特别当内存中无引用对象多了以后, JVM 的 GC 就会开始工作,那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了,每次结果都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ,特别是字符串对象经常改变的情况下。而在某些特别情况下, String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接,所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢,而特别是以下的字符串对象生成中, String 效率是远要比 StringBuffer 快的:



你会很惊讶的发现,生成 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 会规规矩矩的按照原来的方式去做

在大部分情况下 StringBuffer > String


StringBuffer

Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区,但不能修改。虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。

可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步,因此任意特定实例上的所有操作就好像是以串行顺序发生的,该顺序与所涉及的每个线程进行的方法调用顺序一致。

StringBuffer 上的主要操作是 append 和 insert 方法,可重载这些方法,以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。 append 方法始终将这些字符添加到缓冲区的末端;而 insert 方法则在指定的点添加字符。


例如,如果 z 引用一个当前内容是“start”的字符串缓冲区对象,则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”,而 z.insert(4, "le") 将更改字符串缓冲区,使之包含“starlet”。


在大部分情况下 StringBuilder > StringBuffer


java.lang.StringBuilde
java.lang.StringBuilder 一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API,但不保证同步。该类被设计用作 StringBuffer 的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。如果可能,建议优先采用该类,因为在大多数实现中,它比 StringBuffer 要快。两者的方法基本相同。
通过非官方试验测试,StringBuilder和StringBuffer的测试总结如下:

1. 为了获得更好的性能,在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。当然,如果你操作的字符串长度不超过 16 个字符就不用了。

2. 相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升,但却要冒多线程不安全的风险。而在现实的模块化编程中,负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行,因此:除非你能确定你的系统的瓶颈是在 StringBuffer 上,并且确定你的模块不会运行在多线程模式下,否则还是用 StringBuffer 吧 J

3. 用好现有的类比引入新的类更重要。很多程序员在使用 StringBuffer 时是不指定其容量的(至少我见到的情况是这样),如果这样的习惯带入 StringBuilder 的使用中,你将只能获得 10 %左右的性能提升(不要忘了,你可要冒多线程的风险噢);但如果你使用指定容量的 StringBuffer ,你将马上获得 45% 左右的性能提升,甚至比不使用指定容量的 StirngBuilder 都快 30% 左右。


下面的内容转自 火龙果 在论坛上的帖子,非常强大,一并贴过来:

帖子内容:

我有个字符串,需要放很多空格,比如
String str=new String(" ");

甚至比以上的还要多,总感觉不太好,请教大家有没有更好的办法放这些空格呢,谢谢

火龙果 首先给出了一个据说比StringBuffer要快一些的解决方案,因为是直接用的char【】数组:

用这个方法吧,这个要比用 StringBuffer 快一点

Java code
public class Test1 { public static void main(String[] args) { System.out.println("|" + generateSpace(5) + "|"); } public static String generateSpace(int count) { if(count < 0) { throw new IllegalArgumentException("count must be great equal than 0."); } char[] chs = new char[count]; for(int i = 0; i < count; i++) { chs[i] = ' '; } return new String(chs); } }

然后在下面给出了一个非常强大的解释:

看来这个问题讨论的人挺多的,呵呵,做了个小实验以供进行性能比较:

Java code
性能测试报告 (单位:纳秒) +-----------+---------------+---------------+---------------+ | | char[] | StringBuilder | StringBuffer | +-----+-----+---------------+---------------+---------------+ | | C | 164934 | 217095 | 449021 | | A +-----+---------------+---------------+---------------+ | | S | -- | 488630 | 670028 | +-----+-----+---------------+---------------+---------------+ | | C | -- | 454022 | 616225 | | B +-----+---------------+---------------+---------------+ | | S | -- | 703524 | 862583 | +-----+-----+---------------+---------------+---------------+ A -- 对容量进行初始化 B -- 未对容量进行初始化 C -- 采用 char 空格填充 S -- 采用 String 空格填充



测试代码

循环 10000 次(用于对 JVM 进行预热)生成 10000 个字符长度的空格,求其平均数。
每种测试执行 5 次,取最小的输出时间。

Java code
public class Test { public static void main(String[] args) { long t0, t1; String str = null; final int COUNT = 10000; t0 = System.nanoTime(); for(int i = 0; i < COUNT; i++) { str = generateSpace(10000); } t1 = System.nanoTime(); System.out.println((t1 - t0) / (float)COUNT); System.out.println(str.length()); } }



char[] A-C 组代码
Java code
public static String generateSpace(int count) { if(count < 0) { throw new IllegalArgumentException("count must be greater than or equal 0."); } char[] chs = new char[count]; for(int i = 0; i < count; i++) { chs[i] = ' '; } return new String(chs); }



StringBuilder A-C 组代码
StringBuilder 与 StringBuffer 的代码一致,A 代码与 B 代码一致,
只是 A 对其容量进行了初始化,而 B 代码没有进行初始。

Java code
public static String generateSpace(int count) { if(count < 0) { throw new IllegalArgumentException("count must be greater than or equal 0."); } // A 组初始化时给定 count,B 组初始化时不给定 count StringBuilder sb = new StringBuilder(count); for(int i = 0; i < count; i++) { sb.append(' '); // C 组使用字符空格,S 组使用字符串空格 } return sb.toString(); }



结论

从上面的测试结果可以看出,使有不同的方法生成空格的效率有很大的差别,以 char[] 的
执行速度最快。

● StringBuilder 和 StringBuffer 两者由于同步的原因也有不小的差别。
● 由于生成的空格数量是已知的,对于 StringBuilder 和 StringBuffer 的影响是非常大的。
执行速度相差在 50% 以上。
● append 添加空格时,对于空格的选择也很有讲究。空格属于单字符,采用 char 类型和 String
执行速度相差也在 50% 以上。


对于生成固定长度空格的方法选择来说,使用 char[], StringBuffer, StringBuilder 哪一种,
如选择后两者,如果容量是已经知的我们得选择对其容量进行初始化,如果是单字符时应采用 char
进行 append。

当然了,对于 StringBuffer, StingBuilder 来说,算法还可以再进行优化,比如:添加 10000 个
长度的空格的话,可以先添加 100 个生成一个字符串,然后再添加 100 次这个字符串,这时的效率会
有大幅度地提升
(经实验 StringBuilder A-C 测试时间为 186928,比原来 217095 提升了 13% 的
速度)。由于生成的空格数量是不定的,在倍数选择以及非整数倍时需要精心地进行处理。

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics