小瓜牛漫谈 — String、StringBuffer、StringBuilder
来源:互联网 发布:锦尚中国的源码怎么样 编辑:程序博客网 时间:2024/05/17 17:15
任何一个系统在开发的过程中, 相信都不会缺少对字符串的处理。
在 java 语言中, 用来处理字符串的的类常用的有 3 个: String、StringBuffer、StringBuilder。
它们的异同点:
1) 都是 final 类, 都不允许被继承;
2) String 长度是不可变的, StringBuffer、StringBuilder 长度是可变的;
3) StringBuffer 是线程安全的, StringBuilder 不是线程安全的。
String 类已在上一篇随笔 小瓜牛漫谈 — String 中叙述过, 这里就不再赘述。本篇随笔意在漫游 StringBuffer 与 StringBuilder。
其实现在网络上谈论 String、StringBuffer、StringBuilder 的文章已经多到不可胜数了。小瓜牛不才, 蜗行牛步, 慢了半个世纪。。。
StringBuilder 与 StringBuffer 支持的所有操作基本上是一致的, 不同的是, StringBuilder 不需要执行同步。同步操作意味着
要耗费系统的一些额外的开销, 或时间, 或空间, 或资源等, 甚至可能会造成死锁。从理论上来讲, StringBuilder 的速度要更快一些。
串联字符串的性能小测:
1 public class Application { 2 3 private final int LOOP_TIMES = 200000; 4 private final String CONSTANT_STRING = "min-snail"; 5 6 public static void main(String[] args) { 7 8 new Application().startup(); 9 }10 11 public void testString(){12 String string = "";13 long beginTime = System.currentTimeMillis();14 for(int i = 0; i < LOOP_TIMES; i++){15 string += CONSTANT_STRING;16 }17 long endTime = System.currentTimeMillis();18 System.out.print("String : " + (endTime - beginTime) + "\t");19 }20 21 public void testStringBuffer(){22 StringBuffer buffer = new StringBuffer();23 long beginTime = System.currentTimeMillis();24 for(int i = 0; i < LOOP_TIMES; i++){25 buffer.append(CONSTANT_STRING);26 }27 buffer.toString();28 long endTime = System.currentTimeMillis();29 System.out.print("StringBuffer : " + (endTime - beginTime) + "\t");30 }31 32 public void testStringBuilder(){33 StringBuilder builder = new StringBuilder();34 long beginTime = System.currentTimeMillis();35 for(int i = 0; i < LOOP_TIMES; i++){36 builder.append(CONSTANT_STRING);37 }38 builder.toString();39 long endTime = System.currentTimeMillis();40 System.out.print("StringBuilder : " + (endTime - beginTime) + "\t");41 }42 43 public void startup(){44 for(int i = 0; i < 6; i++){45 System.out.print("The " + i + " [\t ");46 testString();47 testStringBuffer();48 testStringBuilder();49 System.out.println("]");50 }51 }52 }
上面示例是频繁的去串联一个比较短的字符串, 然后反复调 6 次。测试是一个很漫长的过程, 在本人的笔记本电脑上总共花去了 23 分钟之多, 下面附上具体数据:
NumberStringStringBufferStringBuilder02312321714123320766223129486323548176423198796523013287 平均 3'52'' 9.2 7.5
从表格数据可以看出, 使用 String 的 "+" 符号串联字符串的性能差的惊人, 大概会维持在 3分40秒 的时候可以看到一次打印结果;
其次是 StringBuffer, 平均花时 9.2 毫秒; 然后是 StringBuilder, 平均花时 7.5 毫秒。
1) 耗时大的惊人的 String 到底是干嘛去了呢? 调出 cmd 窗口, 敲 jconsole 调出 java 虚拟机监控工具, 查看堆内存的使用情况如下:
实际上这个已经在上一篇 小瓜牛漫谈 — String 中提到过, 底层实际上是将循环体内的 string += CONSTANT_STRING; 语句转成了:
string = (new StringBuilder(String.valueOf(string))).append("min-snail").toString();
所以在二十万次的串联字符串中, 每一次都先去创建 StringBuilder 对象, 然后再调 append() 方法来完成 String 类的 "+" 操作。
这里的大部分时间都花在了对象的创建上, 而且每个创建出来的对象的生命都不能长久, 朝生夕灭, 因为这些对象创建出来之后没有引用变量来引用它们,
那么它们在使用完成时候就处于一种不可到达状态, java 虚拟机的垃圾回收器(GC)就会不定期的来回收这些垃圾对象。因此会看到上图堆内存中的曲线起伏变化很大。
但如果是遇到如下情况:
1 String concat1 = "I" + " am " + "min-snail";2 3 String concat2 = "I";4 concat2 += " am ";5 concat2 += "min-snail";
java 对 concat1 的处理速度也是快的惊人。本人在自己的笔记本上测试多次, 耗时基本上都是 0 毫秒。这是因为 concat1 在编译期就可以被确定是一个字符常量。
当编译完成之后 concat1 的值其实就是 "I am min-snail", 因此, 在运行期间自然就不需要花费太多的时间来处理 concat1 了。如果是站在这个角度来看, 使用
StringBuilder 完全不占优势, 在这种情况下, 如果是使用 StringBuilder 反而会使得程序运行需要耗费更多的时间。
但是 concat2 不一样, 由于 concat2 在编译期间不能够被确定, 因此, 在运行期间 JVM 会按老一套的做法, 将其转换成使用 StringBuilder 来实现。
2) 从表格数据可以看出, StringBuilder 与 StringBuffer 在耗时上并不相差多少, 只是 StringBuilder 稍微快一些, 但是 StringBuilder 是
冒着多线程不安全的潜在风险。这也是 StringBuilder 为赚取表格数据中的 1.7 毫秒( 若按表格的数据来算, 性能已经提升 20% 多 )所需要付出的代价。
3) 综合来说:
StringBuilder 是 java 为 StringBuffer 提供的一个等价类, 但不保证同步。在不涉及多线程的操作情况下可以简易的替换 StringBuffer 来提升
系统性能; StringBuffer 在性能上稍略于 StringBuilder, 但可以不用考虑线程安全问题; String 的 "+" 符号操作起来简单方便,
String 的使用也很简单便捷, java 底层会转换成 StringBuilder 来实现, 特别如果是要在循环体内使用, 建议选择其余两个。
使用 StringBuffer、StringBuilder 的无参构造器产生的对象默认拥有 16 个字符长度大小的字符串缓冲区, 如果是调参数为 String 的构造器,
默认的字符串缓冲区容量是 String 对象的长度 + 16 个长度的大小(留 16 个长度大小的空缓冲区)。详细信息可见 StringBuilder 源码:
当使用 append 或 insert 方法向源字符串追加内容的时候, 如果内部缓冲区的大小不够, 就会自动扩张容量, 具体信息看 AbstractStringBuilder 源码:
StringBuffer 与 StringBuilder 是相类似的, 这里就不贴 StringBuffer 的源码了。
不同构造器间的差异:
1 public static void main(String[] args) { 2 3 StringBuilder builder1 = new StringBuilder(""); 4 StringBuilder builder2 = new StringBuilder(10); 5 StringBuilder builder3 = new StringBuilder("min-snail"); // [ 9个字符 ] 6 7 System.out.println(builder1.length()); // 0 8 System.out.println(builder2.length()); // 0 9 System.out.println(builder3.length()); // 910 11 System.out.println(builder1.capacity()); // 1612 System.out.println(builder2.capacity()); // 1013 System.out.println(builder3.capacity()); // 25 [ 25 = 9 + 16 ]14 15 builder2.append("I am min-snail"); // [ 14个字符 ]16 17 System.out.println(builder2.length()); // 1418 System.out.println(builder2.capacity()); // 22 [ 22 = (10 + 1) * 2 ]19 }
从上面的示例代码可以看出, length() 方法计算的是字符串的实际长度, 空字符串的长度为 0 (这个和 String 是一样的: "".length() == 0)。
capacity() 方法是用来计算对象字符串缓冲区的总容量大小:
builder1 为: length + 16 = 0 + 16 = 16;
builder3 为: length + 16 = 9 + 16 = 25;
builder2 由于是直接指定字符串缓冲区的大小, 因此容量就是指定的值 10, 这个从源码的构造器中就能很容易的看出;
当往 builder2 追加 14 个字符长度大小的字符串时, 这时候原有的缓冲区容量不够用, 那么就会自动的扩容: (10 + 1) * 2 = 22
这个从源码的 expandCapacity(int) 方法的第一行就能够看的出。
不同构造器的性能小测:
1 public class Application { 2 3 private final int LOOP_TIMES = 1000000; 4 private final String CONSTANT_STRING = "min-snail"; 5 6 public static void main(String[] args) { 7 8 new Application().startup(); 9 }10 11 public void testStringBuilder(){12 StringBuilder builder = new StringBuilder();13 long beginTime = System.currentTimeMillis();14 for(int i = 0; i < LOOP_TIMES; i++){15 builder.append(CONSTANT_STRING);16 }17 builder.toString();18 long endTime = System.currentTimeMillis();19 System.out.print("StringBuilder : " + (endTime - beginTime) + "\t");20 }21 22 public void testCapacityStringBuilder(){23 StringBuilder builder = new StringBuilder(LOOP_TIMES * CONSTANT_STRING.length());24 long beginTime = System.currentTimeMillis();25 for(int i = 0; i < LOOP_TIMES; i++){26 builder.append(CONSTANT_STRING);27 }28 builder.toString();29 long endTime = System.currentTimeMillis();30 System.out.print("StringBuilder : " + (endTime - beginTime) + "\t");31 }32 33 public void startup(){34 for(int i = 0; i < 10; i++){35 System.out.print("The " + i + " [\t ");36 testStringBuilder();37 testCapacityStringBuilder();38 System.out.println("]");39 }40 }41 }
示例中是频繁的去调 StringBuilder 的 append() 方法往源字符串中追加内容, 总共测试 10 次, 下面附上测试的结果的数据:
NumberStringBuilder()StringBuilder(int)06033143262412534224451305922465524740248552194421 平均 52.3 25.2
从表格数据可以看出, 合理的指定字符串缓冲区的容量可以大大的提高系统的性能(若按表格的数据来算, 性能约提升了 108%), 这是因为 StringBuilder 在
缓冲区容量不足的时候会自动扩容, 而扩容就会涉及到数组的拷贝(StringBuilder 和 StringBuffer 底层都是使用 char 数组来实现的), 这个也可以在源码
的 expandCapacity(int) 方法中看的出。这些额外的开销都是需要花费掉一定量的时间的。
在上示代码中, 如果将 StringBuilder 换成 StringBuffer, 其余保持不变, 测试的结果的数据如下:
NumberSstingBuffer()StringBuffer(int)085581705627356371554735851175568455769558705297352平均 78.555.2
与 StringBuilder 相类似的, 指定容量的构造器在性能上也得到了较大的提升(若按表格数据来算, 性能约提升了 42%), 但由于 StringBuffer 需要
执行同步, 因此性能上会比 StringBuilder 差一些。
from: http://www.cnblogs.com/fancydeepin/archive/2013/04/23/min-snail-speak_String-StringBuffer-StringBuilder.html
- 小瓜牛漫谈 — String、StringBuffer、StringBuilder
- 字符串 —— String?StringBuffer?StringBuilder?
- <java——String、StringBuffer、StringBuilder>
- Java基础——String、StringBuffer、StringBuilder
- java 基础知识——String & StringBuffer & StringBuilder
- 【J2SE】——String、StringBuffer与StringBuilder
- JavaSe——6、String、StringBuffer、StringBuilder
- String—StringBuffer、StringBuilder、基本数类型
- java基础知识—String、StringBuffer和StringBuilder
- 黑马程序员—String、StringBuffer、StringBuilder
- String 、StringBuffer 和 StringBuilder
- String,StringBuffer,StringBuilder(转载)
- String、StringBuffer和StringBuilder
- String,StringBuffer,StringBuilder
- String、StringBuffer和StringBuilder
- String、StringBuffer和StringBuilder
- String StringBuffer StringBuilder
- String StringBuffer StringBuilder
- WampServer中MySQL中文乱码解决
- tensorflow的基本用法(八)——dropout的作用
- 【MySQL基础】事务与存储过程
- Ubuntu下tensorflow安装
- LeetCode 165. Compare Version Numbers
- 小瓜牛漫谈 — String、StringBuffer、StringBuilder
- 浮点数的二进制表示
- IOS
- MySQL的查询方法
- MYSQL常用命令
- JVM概述
- Java 性能优化之 String 篇
- 自定义radiobutton样式
- 1025. 反转链表 (25) python篇