`
Leon.Wood
  • 浏览: 288235 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

是 String ， StringBuffer 还是 StringBuilder ？

JavaJVMNetbeansJ2SEIDE 
阅读更多
相信大家对 String 和 StringBuffer 的区别也已经很了解了，但是估计还是会有很多同志对这两个类的工作原理有些不清楚的地方，今天我在这里重新把这个概念给大家复习一下，顺便牵出 J2SE 5.0 里面带来的一个新的字符操作的类—— StringBuilder （先别忙着扔我砖头，我还算清醒，我这里说的不是 C ＃， Java 也有 StringBuilder 类）。那么这个 StringBuilder 和 StringBuffer 以及我们最早遇见的 String 类有那些区别呢？在不同的场合下我们应该用哪个呢？我讲讲自己对这几个类的一点看法，也希望大家提出意见，每个人都有错的地方，在错了改的同时更是一个学习的好机会。

       简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象（为什么？问问 Java 的设计者吧，为什么 String 不是原生类型呢？）因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。这里尝试举个不是很恰当的例子：

       String S1 = “abc”;

       For(int I = 0 ; I < 10000 ; I ++)  // For 模拟程序的多次调用

       {

              S1 + = “def”;

              S1 = “abc”;

}

如果是这样的话，到这个 for 循环完毕后，如果内存中的对象没有被 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 会规规矩矩的按照原来的方式去做， S1 对象的生成速度就不像刚才那么快了，一会儿我们可以来个测试作个验证。

由此我们得到第一步结论：

在大部分情况下 StringBuffer > String

       而 StringBuilder 跟他们比又怎么样呢？先简单介绍一下， StringBuilder 是 JDK5.0 中新增加的一个类，它跟 StringBuffer 的区别看下面的介绍（来源 JavaWorld ）：

       Java.lang.StringBuffer 线程安全的可变字符序列。类似于 String 的字符串缓冲区，但不能修改。可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

       每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5.0 开始，为该类增添了一个单个线程使用的等价类，即 StringBuilder 。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

但是如果将 StringBuilder 的实例用于多个线程是不安全的。需要这样的同步，则建议使用 StringBuffer 。

这样说估计大家都能明白他们之间的区别了，那么下面我们再做一个一般性推导：

在大部分情况下 StringBuilder > StringBuffer

因此，根据这个不等式的传递定理： 在大部分情况下

StringBuilder > StringBuffer > String

既然有这样的推导结果了，我们做个测试验证一下：

测试代码如下：

 

Java代码 复制代码
  1. public class testssb {    
  2.   
  3.        
  4.   
  5.     /** Creates a new instance of testssb */    
  6.   
  7.     final static int ttime = 10000;// 测试循环次数    
  8.   
  9.     public testssb() {    
  10.   
  11.     }    
  12.   
  13.        
  14.   
  15.     public void test(String s){    
  16.   
  17.         long begin = System.currentTimeMillis();    
  18.   
  19.         for(int i=0;i<ttime;i++){    
  20.   
  21.             s += "add";    
  22.   
  23.         }    
  24.   
  25.         long over = System.currentTimeMillis();    
  26.   
  27.         System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： "    
  28.   
  29.             + (over - begin) + " 毫秒 " );           
  30.   
  31.     }    
  32.   
  33.     public void test(StringBuffer s){    
  34.   
  35.         long begin = System.currentTimeMillis();    
  36.   
  37.         for(int i=0;i<ttime;i++){    
  38.   
  39.             s.append("add");    
  40.   
  41.         }    
  42.   
  43.         long over = System.currentTimeMillis();    
  44.   
  45.         System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： "    
  46.   
  47.             + (over - begin) + " 毫秒 " );           
  48.   
  49.     }    
  50.   
  51.     public void test(StringBuilder s){    
  52.   
  53.         long begin = System.currentTimeMillis();    
  54.   
  55.         for(int i=0;i<ttime;i++){    
  56.   
  57.             s.append("add");    
  58.   
  59.         }    
  60.   
  61.         long over = System.currentTimeMillis();    
  62.   
  63.         System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： "    
  64.   
  65.             + (over - begin) + " 毫秒 " );           
  66.   
  67.     }    
  68.   
  69.     // 对 String 直接进行字符串拼接的测试    
  70.   
  71.     public void test2(){    
  72.   
  73.         String s2 = "abadf";    
  74.   
  75.         long begin = System.currentTimeMillis();    
  76.   
  77.         for(int i=0;i<ttime;i++){    
  78.   
  79.             String s = s2 + s2 + s2 ;    
  80.   
  81.         }    
  82.   
  83.         long over = System.currentTimeMillis();    
  84.   
  85.         System.out.println(" 操作字符串对象引用相加类型使用的时间为： "    
  86.   
  87.             + (over - begin) + " 毫秒 " );           
  88.   
  89.     }    
  90.   
  91.     public void test3(){    
  92.   
  93.         long begin = System.currentTimeMillis();    
  94.   
  95.         for(int i=0;i<ttime;i++){    
  96.   
  97.             String s = "abadf" + "abadf" + "abadf" ;    
  98.   
  99.         }    
  100.   
  101.         long over = System.currentTimeMillis();    
  102.   
  103.         System.out.println(" 操作字符串相加使用的时间为： "    
  104.   
  105.             + (over - begin) + " 毫秒 " );           
  106.   
  107.     }    
  108.   
  109.        
  110.   
  111.     public static void main(String[] args){    
  112.   
  113.     String s1 ="abc";    
  114.   
  115.     StringBuffer sb1 = new StringBuffer("abc");    
  116.   
  117.     StringBuilder sb2 = new StringBuilder("abc");    
  118.   
  119.     testssb t = new testssb();    
  120.   
  121.     t.test(s1);    
  122.   
  123.     t.test(sb1);    
  124.   
  125.     t.test(sb2);    
  126.   
  127.     t.test2();    
  128.   
  129.     t.test3();    
  130.   
  131.     }    
  132.   
  133. }   
Java代码 复制代码
  1. <SPAN style="FONT-SIZE: x-small">public class testssb {    
  2.   
  3.        
  4.   
  5.     /** Creates a new instance of testssb */    
  6.   
  7.     final static int ttime = 10000;// 测试循环次数    
  8.   
  9.     public testssb() {    
  10.   
  11.     }    
  12.   
  13.        
  14.   
  15.     public void test(String s){    
  16.   
  17.         long begin = System.currentTimeMillis();    
  18.   
  19.         for(int i=0;i<ttime;i++){    
  20.   
  21.             s += "add";    
  22.   
  23.         }    
  24.   
  25.         long over = System.currentTimeMillis();    
  26.   
  27.         System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： "    
  28.   
  29.             + (over - begin) + " 毫秒 " );           
  30.   
  31.     }    
  32.   
  33.     public void test(StringBuffer s){    
  34.   
  35.         long begin = System.currentTimeMillis();    
  36.   
  37.         for(int i=0;i<ttime;i++){    
  38.   
  39.             s.append("add");    
  40.   
  41.         }    
  42.   
  43.         long over = System.currentTimeMillis();    
  44.   
  45.         System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： "    
  46.   
  47.             + (over - begin) + " 毫秒 " );           
  48.   
  49.     }    
  50.   
  51.     public void test(StringBuilder s){    
  52.   
  53.         long begin = System.currentTimeMillis();    
  54.   
  55.         for(int i=0;i<ttime;i++){    
  56.   
  57.             s.append("add");    
  58.   
  59.         }    
  60.   
  61.         long over = System.currentTimeMillis();    
  62.   
  63.         System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： "    
  64.   
  65.             + (over - begin) + " 毫秒 " );           
  66.   
  67.     }    
  68.   
  69.     // 对 String 直接进行字符串拼接的测试    
  70.   
  71.     public void test2(){    
  72.   
  73.         String s2 = "abadf";    
  74.   
  75.         long begin = System.currentTimeMillis();    
  76.   
  77.         for(int i=0;i<ttime;i++){    
  78.   
  79.             String s = s2 + s2 + s2 ;    
  80.   
  81.         }    
  82.   
  83.         long over = System.currentTimeMillis();    
  84.   
  85.         System.out.println(" 操作字符串对象引用相加类型使用的时间为： "    
  86.   
  87.             + (over - begin) + " 毫秒 " );           
  88.   
  89.     }    
  90.   
  91.     public void test3(){    
  92.   
  93.         long begin = System.currentTimeMillis();    
  94.   
  95.         for(int i=0;i<ttime;i++){    
  96.   
  97.             String s = "abadf" + "abadf" + "abadf" ;    
  98.   
  99.         }    
  100.   
  101.         long over = System.currentTimeMillis();    
  102.   
  103.         System.out.println(" 操作字符串相加使用的时间为： "    
  104.   
  105.             + (over - begin) + " 毫秒 " );           
  106.   
  107.     }    
  108.   
  109.        
  110.   
  111.     public static void main(String[] args){    
  112.   
  113.     String s1 ="abc";    
  114.   
  115.     StringBuffer sb1 = new StringBuffer("abc");    
  116.   
  117.     StringBuilder sb2 = new StringBuilder("abc");    
  118.   
  119.     testssb t = new testssb();    
  120.   
  121.     t.test(s1);    
  122.   
  123.     t.test(sb1);    
  124.   
  125.     t.test(sb2);    
  126.   
  127.     t.test2();    
  128.   
  129.     t.test3();    
  130.   
  131.     }    
  132.   
  133. } </SPAN>  
public class testssb { 

    

    /** Creates a new instance of testssb */ 

    final static int ttime = 10000;// 测试循环次数 

    public testssb() { 

    } 

    

    public void test(String s){ 

        long begin = System.currentTimeMillis(); 

        for(int i=0;i<ttime;i++){ 

            s += "add"; 

        } 

        long over = System.currentTimeMillis(); 

        System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " 

            + (over - begin) + " 毫秒 " );        

    } 

    public void test(StringBuffer s){ 

        long begin = System.currentTimeMillis(); 

        for(int i=0;i<ttime;i++){ 

            s.append("add"); 

        } 

        long over = System.currentTimeMillis(); 

        System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " 

            + (over - begin) + " 毫秒 " );        

    } 

    public void test(StringBuilder s){ 

        long begin = System.currentTimeMillis(); 

        for(int i=0;i<ttime;i++){ 

            s.append("add"); 

        } 

        long over = System.currentTimeMillis(); 

        System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " 

            + (over - begin) + " 毫秒 " );        

    } 

    // 对 String 直接进行字符串拼接的测试 

    public void test2(){ 

        String s2 = "abadf"; 

        long begin = System.currentTimeMillis(); 

        for(int i=0;i<ttime;i++){ 

            String s = s2 + s2 + s2 ; 

        } 

        long over = System.currentTimeMillis(); 

        System.out.println(" 操作字符串对象引用相加类型使用的时间为： " 

            + (over - begin) + " 毫秒 " );        

    } 

    public void test3(){ 

        long begin = System.currentTimeMillis(); 

        for(int i=0;i<ttime;i++){ 

            String s = "abadf" + "abadf" + "abadf" ; 

        } 

        long over = System.currentTimeMillis(); 

        System.out.println(" 操作字符串相加使用的时间为： " 

            + (over - begin) + " 毫秒 " );        

    } 

    

    public static void main(String[] args){ 

    String s1 ="abc"; 

    StringBuffer sb1 = new StringBuffer("abc"); 

    StringBuilder sb2 = new StringBuilder("abc"); 

    testssb t = new testssb(); 

    t.test(s1); 

    t.test(sb1); 

    t.test(sb2); 

    t.test2(); 

    t.test3(); 

    } 

}

 

以上代码在 NetBeans 5.0 IDE/JDK1.6 上编译通过

循环次数 ttime 为 10000 次的测试结果如下：

Java代码 复制代码
  1. 操作 java.lang.String 类型使用的时间为： 4392 毫秒    
  2. 操作 java.lang.StringBuffer 类型使用的时间为： 0 毫秒    
  3. 操作 java.lang.StringBuilder 类型使用的时间为： 0 毫秒    
  4. 操作字符串对象引用相加类型使用的时间为： 15 毫秒    
  5. 操作字符串相加使用的时间为： 0 毫秒   
Java代码 复制代码
  1. <SPAN style="FONT-SIZE: x-small">操作 java.lang.String 类型使用的时间为： 4392 毫秒    
  2. 操作 java.lang.StringBuffer 类型使用的时间为： 0 毫秒    
  3. 操作 java.lang.StringBuilder 类型使用的时间为： 0 毫秒    
  4. 操作字符串对象引用相加类型使用的时间为： 15 毫秒    
  5. 操作字符串相加使用的时间为： 0 毫秒 </SPAN>  
操作 java.lang.String 类型使用的时间为： 4392 毫秒 
操作 java.lang.StringBuffer 类型使用的时间为： 0 毫秒 
操作 java.lang.StringBuilder 类型使用的时间为： 0 毫秒 
操作字符串对象引用相加类型使用的时间为： 15 毫秒 
操作字符串相加使用的时间为： 0 毫秒

 

好像还看不出 StringBuffer 和 StringBuilder 的区别，把 ttime 加到 30000 次看看：

 

 

 

Java代码 复制代码
  1. 操作 java.lang.String 类型使用的时间为： 53444 毫秒    
  2. 操作 java.lang.StringBuffer 类型使用的时间为： 15 毫秒   
  3. 操作 java.lang.StringBuilder 类型使用的时间为： 15 毫秒    
  4. 操作字符串对象引用相加类型使用的时间为： 31 毫秒    
  5. 操作字符串相加使用的时间为： 0 毫秒   
Java代码 复制代码
  1. <SPAN style="FONT-SIZE: x-small">操作 java.lang.String 类型使用的时间为： 53444 毫秒    
  2. 操作 java.lang.StringBuffer 类型使用的时间为： 15 毫秒   
  3. 操作 java.lang.StringBuilder 类型使用的时间为： 15 毫秒    
  4. 操作字符串对象引用相加类型使用的时间为： 31 毫秒    
  5. 操作字符串相加使用的时间为： 0 毫秒 </SPAN>  
操作 java.lang.String 类型使用的时间为： 53444 毫秒 
操作 java.lang.StringBuffer 类型使用的时间为： 15 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 15 毫秒 
操作字符串对象引用相加类型使用的时间为： 31 毫秒 
操作字符串相加使用的时间为： 0 毫秒

    StringBuffer 和 StringBuilder 的性能上还是没有太大的差异，再加大到 100000 看看，这里就不加入对 String 类型的测试了，因为对 String 类型这么大数据量的测试会很慢滴…… 

Java代码 复制代码
  1. 操作 java.lang.StringBuffer 类型使用的时间为： 31 毫秒    
  2. 操作 java.lang.StringBuilder 类型使用的时间为： 16 毫秒   
Java代码 复制代码
  1. <SPAN style="FONT-SIZE: x-small">操作 java.lang.StringBuffer 类型使用的时间为： 31 毫秒    
  2. 操作 java.lang.StringBuilder 类型使用的时间为： 16 毫秒    
  3. </SPAN>  
操作 java.lang.StringBuffer 类型使用的时间为： 31 毫秒 
操作 java.lang.StringBuilder 类型使用的时间为： 16 毫秒

 

能看出差别了，但其中有多次的测试结果居然是 StringBuffer 比 StringBuilder 快，再加大一些到

分享到：
| 选择抽象类还是接口
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    String StringBuffer和StringBuilder区别之源码解析

    "String StringBuffer和StringBuilder区别之源码解析" 在Java中，字符串是我们经常使用的数据类型，而String、StringBuffer和StringBuilder是Java中三种常用的字符串类。在这篇文章中，我们将从源码角度对String、...

    String ，StringBuffer与StringBuilder

    String, StringBuffer 与 StringBuilder 的区别 在 Java 中，String, StringBuffer 和 StringBuilder 三个类都是用于字符操作的，但它们之间有着很大的区别。 首先，String 是不可变类，意味着一旦创建了 String ...

    String、StringBuffer与StringBuilder之间区别

    　StringBuffer：字符创变量 　StringBuilder：字符创变量 　从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问 ，比如这段代码：

    String、StringBuffer、StringBuilder的使用方法

    在Java编程语言中，`String`、`StringBuffer`和`StringBuilder`是处理字符串的三个重要类，它们各自有特定的使用场景和优缺点。理解它们的差异对于编写高效的代码至关重要。 **String类** `String`是不可变的类，...

    String及StringBuffer和StringBuilder的区别

    String、StringBuffer 和 StringBuilder 是 Java 语言中三种不同类型的字符串处理方式，它们之间存在着明显的性能和线程安全性差异。 String String 类型是不可变的对象，每次对 String 对象进行改变时都会生成一...

    String-StringBuffer-StringBuilder

    在Java编程语言中，`String`、`StringBuffer`和`StringBuilder`都是用来处理字符串的类，但它们之间存在显著的差异，主要体现在性能、线程安全性和使用场景上。 首先，`String`是最基本的字符串类，它代表的是不可...

    String、StringBuilder和StringBuffer的区别

    在Java编程语言中，String、StringBuilder和StringBuffer都是用来处理字符串的类，它们之间存在一些重要的区别，主要涉及到性能和线程安全性。 首先，`String`类代表的是字符串常量，一旦创建，其内容就不能改变。...

    string,stringbuffer,stringbuilder

    string,stringbuffer,stringbuilder

    Java中String,StringBuffer与StringBuilder的区别

    Java 中 String, StringBuffer 与 StringBuilder 的区别 Java 中 String, StringBuffer 与 StringBuilder 三种字符串类型的区别是很多开发者经常混淆或不了解的知识点。今天，我们将深入探讨这三种字符串类型的区别...

    string，stringBuffer，stringBuilder

    string，stringBuffer，stringBuilder

    String&StringBuffer&StringBuilder三者之间的区别-经典解析.doc

    在Java编程语言中，String、StringBuffer和StringBuilder都是用来处理字符串的重要类，它们各自有特定的使用场景和特性。理解这三个类的区别对于任何Java开发者，无论是初学者还是经验丰富的程序员，都是非常重要的...

    你知道String、StringBuffer和StringBuilder的区别吗

    在选择使用`StringBuffer`还是`StringBuilder`时，通常遵循以下原则： 1. 如果你在单线程环境中工作，或者字符串操作不是性能瓶颈，那么推荐使用`StringBuilder`，因为它更快。 2. 如果你的代码将在多线程环境下运行...

    《剑指offer》Java-String、StringBuffer 和 StringBuilder 的区别.pdf

    在Java编程语言中，String、StringBuffer和StringBuilder都是用来处理字符串的对象，但它们之间存在显著的区别。String是最常见的字符串类型，它的特点是不可变性。这意味着一旦一个String对象被创建，就不能进行...

    BATJ面试题讲解-String、StringBuffer、StringBuilder的区别

    BATJ面试题讲解-String、StringBuffer、StringBuilder的区别

    Java 中 String，StringBuffer 和 StringBuilder 的区别及用法

    "Java 中 String、StringBuffer 和 StringBuilder 的区别及用法" Java 中 String、StringBuffer 和 StringBuilder 是三个常用的字符串操作类，了解它们之间的区别对 Java 开发者来说非常重要。本文将详细介绍这三者...

    Java面试题-每日一题：String、StringBuffer、StringBuilder的区别

    Java面试题-每日一题：String、StringBuffer、StringBuilder的区别

    String和StringBuffer的区别

    在Java编程语言中，`String`和`StringBuffer`都是用来表示和操作字符串的重要类，但它们在性能和使用场景上有显著的区别。 首先，`String`类是不可变的，这意味着一旦创建了一个`String`对象，它的内容就不能改变。...

    StringBuffer、StringBuilder、String

    ### StringBuffer、StringBuilder、String #### 一、概述 在Java编程语言中，处理字符串是非常常见的需求之一。在Java中，有几种不同的方式可以用来创建和修改字符串，其中最常用的是`String`、`StringBuffer`和`...

    浅谈java中String StringBuffer StringBuilder的区别

    在Java编程语言中，String、StringBuffer和StringBuilder都是用来处理字符串的类，但它们之间存在显著的性能和功能差异。下面我们将深入探讨这三个类的区别。 首先，`String`类是Java中最基本的字符串类型，它表示...

Magicbox
Global site tag (gtag.js) - Google Analytics