`
qwex9iao
  • 浏览: 177078 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

String和StringBuffer

    博客分类:
  • java
阅读更多
String和StringBuffer的一些用法      
  先看一个例子~~~~  
   
  public   class   Untitled1   {  
      public   Untitled1()   {  
      }  
      public   static   void   main(String[]   args)   {  
          Untitled1   untitled11   =   new   Untitled1();  
          String   s1="STRING类的值是不是会变的->";  
          String   s2=s1;  
          System.out.println(s2);  
          s1+="加个试试";   //String   赋值实际上这个是NEW了一个新的对象了,S1变了  
          System.out.println(s2);   //S2没有变,这是因为S2指向的地址还是最早的s1所在的地址  
       
          StringBuffer   b1=new   StringBuffer("StringBuffer类的值是会变的->");  
          StringBuffer   b2=b1;  
          b2.append("加个试试");//StringBuffer赋值,操作b2还是那个对象,  
          System.out.println(b1);//所以加一个字符进去b1指向的对象的值已经变了哦  
      }  
  }  
   
  结果:  
  STRING类的值是不是会变的->  
  STRING类的值是不是会变的->  
  StringBuffer类的值是会变的->加个试试  
   
   
  摘录:  
   
  CSDN:  
  这里的"可变"和"不可变",和是不是final没有关系  
   
  举个例子:  
   
  String   str1   =   "hello";  
  String   str2   =   "world";  
  String   str1   =   str1   +  
str2;//这里所做的内部操作,其实不是把str1的内容改变为原str1+str2的内容这么简单,   而把创建一个新的String,   内容为str1  
+   str2的内容,然后再把str1这个引用重新指向新创建的String,   这就是上面说的String不可变.  
   
  而如果是StringBuffer的话,则直接更改str1的内容,而不是先创建一个新的StringBuffer  
   
   
  使用   StringBuffer   主要就是在性能上的考虑。  
   
  String   是一种非常常用的数据类型,但由于   String   是不可变对象,在进行   String   的相关操作的时候会产生许多临时的  
String   对象。  
   
  而   StringBuffer   在操作上是在一个缓冲中进行的,性能当然优越得多。  
   
  不过,一般做为简单的字符串传递和其它操作,只不要改变字符串内容的操作,用   String   效率会高一些。  
       
  记得以前在网上看到一篇关于java面试题的文章,里面好像有个题就是关于String与StringBuffer的,具体的记不清了,大概内容如下:  
   
  请说出下面代码块存在的问题:  
   
  String   tmp   =   “”;  
   
  for(int   i=0;i<n;I++){  
   
          tmp   +=”x”;  
   
  }  
   
 
当时网上有人只是简单的说了要改用StringBuffer,这个存在效率问题,而没有进一步说明,其实我也很郁闷,是什么效率问题呢?“顾名思义,StringBuffer之所以效率好,应该是它提供了缓存机制吧”,我想很多朋友是这样想的吧,HOHO。
 
   
  当昨天晚上读到Effective  
java一书的时候,我才恍然大悟,原来String是一个支持非可变性的类,这种类的特点是状态固定(不存在任何修改对象的方法),在该对象的生存周期内,它的值是永远不变的(它是线程安全的),它们更容易设计、实现、使用,不易出错,更加安全。  
   
  由于String类是支持非可变性的,所以,当执行tmp  
+=”x”的时候,实际上是另外创建了一个对象,而tmp原来指向的那个对象就成了垃圾(当它没有其它引用的时候),这样的话一个循环就会产生n多对象,可以相象内存的浪费,怕怕。
     
可以看出,它是重新创建了一个新的对象,符合“支持非可变性”的原则,但这却也显示出了非可变类的真正惟一的缺点,就是“对于每一个不同的值都要求一个单独的对象”。  
   
那为什么String要设计成非可变类呢?我觉得String是java中使用最为频繁的一个类,只有使其支持非可变性,才有可能避免一系列的问题,比如说:  
   
  String   a,b,c;  
   
  a=”test”;  
   
  b=a;  
   
  c=b;  
   
  processA(){  
   
          ……..  
   
  }  
   
  ProcessB(){  
   
          ……..  
   
  }  
   
  ProcessC(){  
   
          ……..  
   
  }  
   
  当String支持非可变性的时候,它们的值很好确定,不管调用哪个方法,都互不影响,如果它不支持的话,那么我无法想象其结果。  
   
  StringBuffer做为String的“配套类(companying  
class)”,它的作用就是为了解决上述问题的,StringBuffer扮演了String的可变配套类角色。非可变类本质上是线程安全的,它们不要求做同步处理,我们可以将其共享给所有用户,让所有的“客户端程序员”都可以直接使用此类而不需要做任何额外的工作。
 
   
 
  
out.println("Time   taken   for   String   concatenation   using  
StringBuffer   :   "    +   (endTime1   -   startTime1)+   "  milli  
seconds");  
      }  
  }  
  这是上面的代码的输出结果:  
  Time   taken   for   String   concatenation   using   +   operator   :   0  
milli   seconds  
  Time   taken   for   String   concatenation   using   StringBuffer   :   50  
milli   seconds  
  很有趣地,+操作符居然比StringBuffer.append()方法要快,为什么呢?      
  这里编译器的优化起了关键作用,编译器像下面举例的那样简单地在编译期连接多个字符串。它使用编译期决定取代运行期决定,在你使用new关键字来创建String对象的时候也是如此。
      编译前:  
  String   result   =   "This   is"+"testing  
the"+"difference"+"between"+"String"+"and"+"StringBuffer";  
  编译后:  
  String   result   =   "This   is   testing   the   difference   between  
String   and   StringBuffer";    
 
这里String对象在编译期就决定了而StringBuffer对象是在运行期决定的。运行期决定需要额外的开销当字符串的值无法预先知道的时候,编译期决定作用于字符串的值可以预先知道的时候,下面是一个例子。
      编译前:  
  public   String   getString(String   str1,String   str2)   {  
          return   str1+str2;  
  }  
  编译后:  
  return   new   StringBuffer().append(str1).append(str2).toString();  
  运行期决定需要更多的时间来运行。       2)   第二种情景:使用StringBuffer取代String  
  看看下面的代码你会发现与情景一相反的结果――连接多个字符串的时候StringBuffer要比String快。  
  StringTest4.java       package   com.performance.string;   /**   This   class 
shows   the   time   taken   by   string   concatenation    
  using   +   operator   and   StringBuffer     */  
  public   class   StringTest4   {     public   static   void   main(String[]  
args){  
[/align]
          //Test   the   String   Concatenation   using   +   operator  
          long   startTime   =   System.currentTimeMillis();  
          String   result   =   "hello";  
          for(int   i=0;i<1500;i++){  
                  result   +=   "hello";  
          }           long   endTime   =   System.currentTimeMillis();  
          System.out.println("Time   taken   for   string   concatenation  
using   +   operator   :   "  
                                      +   (endTime   -   startTime)+   "   milli
  seconds");           //Test   the   String   Concatenation   using  
StringBuffer  
          long   startTime1   =   System.currentTimeMillis();  
          StringBuffer   result1   =   new   StringBuffer("hello");  
          for(int   i=0;i<1500;i++){  
                  result1.append("hello");  
          }           long   endTime1   =   System.currentTimeMillis();  
          System.out.println("Time   taken   for   string   concatenation  
using   StringBuffer   :     "    
                                      +   (endTime1   -   startTime1)+   "  
milli   seconds");  
          }  
  }  
  这是上面的代码的输出结果:  
  Time   taken   for   string   concatenation   using   +   operator   :   280  
milli   seconds  
  Time   taken   for   String   concatenation   using   StringBuffer   :   0  
milli   seconds   看得出StringBuffer.append()方法要比+操作符要快得多,为什么呢?   [align=left]

 
  原因是两者都是在运行期决定字符串对象,但是+操作符使用不同于StringBuffer.append()的规则通过String和StringBuffer来完成字符串连接操作。(译注:什么样的规则呢?)
      借助StringBuffer的初始化过程的优化技巧  
    你可以通过StringBuffer的构造函数来设定它的初始化容量,这样可以明显地提升性能。这里提到的构造函数是StringBuffer(int  
length),length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int  
minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为,然后再找出一条更好的提升性能的途径。
      StringBuffer的缺省行为:  
 
  StringBuffer在内部维护一个字符数组,当你使用缺省的构造函数来创建StringBuffer对象的时候,因为没有设置初始化字符长度,StringBuffer的容量被初始化为16个字符,也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候,它会将自身容量增加到当前的2倍再加2,也就是(2*旧值+2)。
 
  如果你使用缺省值,初始化之后接着往里面追加字符,在你追加到第16个字符的时候它会将容量增加到34(2*16+2),当追加到34个字符的时候就会将容量增加到70(2*34+2)。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的,这样会带来立竿见影的性能增益。  
  我利用两个StringBuffer重新测试了上面的StringTest4.java代码,一个未使用初始化容量值而另一个使用了。这次我追加了50000个’hello’对象没有使用+操作符。区别是我使用StringBuffer(250000)的构造函数来初始化第二个StringBuffer了。
      输出结果如下:  
  Time   taken   for   String   concatenation   using   StringBuffer   with  
out   setting   size:   280   milli   seconds  
  Time   taken   for   String   concatenation   using   StringBuffer   with  
setting   size:   0   milli   seconds  
StringBuffer初始化过程的调整的作用由此可见一斑。所以,使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。      
关键点  
  1.   无论何时只要可能的话使用字符串字面量来常见字符串而不是使用new关键字来创建字符串。  
  2.   无论何时当你要使用new关键字来创建很多内容重复的字符串的话,请使用String.intern()方法。  
  3.   +操作符会为字符串连接提供最佳的性能――当字符串是在编译期决定的时候。  
  4.   如果字符串在运行期决定,使用一个合适的初期容量值初始化的StringBuffer会为字符串连接提供最佳的性能。
分享到:
评论

相关推荐

    javaString 和StringBuffer的区别

    JAVA平台提供了两个类:String和StringBuffer,它们可以储存和操作字符串,即包含多个字符的字符数据.这个String类提供了数值不可改变的字符串.而这个StringBuffer类提供的字符串进行修改.当你知道字符数据要改变的时候...

    String 和StringBuffer的区别

    从非常细致的角度分析了String和Stringbuffer的主要区别

    String和StringBuffer的区别

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

    源码string和stringbuffer

    针对String的详细介绍针对String的详细介绍针对String的详细介绍针对String的详细介绍针对String的详细介绍针对String的详细介绍针对String的详细介绍针对String的详细介绍针对String的详细介绍针对String的详细介绍...

    String StringBuffer和StringBuilder区别之源码解析

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

    String ,StringBuffer与StringBuilder

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

    string和StringBuffer的区别

    在Java编程语言中,`String`和`StringBuffer`都是用来表示和操作字符串的重要类,但它们在使用场景和性能上有显著的区别。了解这些差异对于编写高效、优化的代码至关重要。 首先,`String`类是不可变的。这意味着...

    String、StringBuffer、StringBuilder的使用方法

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

    Java中String和StringBuffer的区别.doc

    在Java编程语言中,String和StringBuffer是两个重要的类,它们在处理文本数据时有着显著的区别。String类代表不可变的字符序列,一旦创建,其值就不能改变。这意味着每次对String对象进行修改(如拼接操作)都会创建...

    java面试笔试题String 和StringBuffer的区别

    在Java编程语言中,`String`与`StringBuffer`是两个重要的字符串处理类,它们各自具有独特的特性和用途,尤其在面试或笔试中常被提及作为考察应聘者对Java基础知识掌握程度的重要知识点。 ### `String`类:不可变性...

    String、StringBuilder和StringBuffer的区别

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

    java中 String和StringBuffer的区别实例详解

    Java中String和StringBuffer的区别实例详解 Java中String和StringBuffer都是用来存储字符串的对象,但是它们之间有着很大的区别。下面我们来详细介绍Java中String和StringBuffer的区别实例详解。 首先,String是不...

    String及StringBuffer和StringBuilder的区别

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

    String和StringBuffer详细用法总结

    ### `String` 和 `StringBuffer` 的基本概念 #### `String` 在Java中,`String` 类表示不可变的字符序列,也就是说一旦创建了一个字符串对象后,其内容就不能被更改。这使得`String`对象非常适合于处理固定不变的...

    String和StringBuffer深入.doc

    在Java编程语言中,`String`和`StringBuffer`是两个非常重要的类,它们都用于表示文本字符串。然而,它们之间存在着本质的区别,这主要体现在它们的可变性、性能和使用场景上。 首先,`String`类是不可变的,意味着...

    String和StringBuffer专题

    在Java编程语言中,`String`和`StringBuffer`是两个非常重要的类,它们与字符串操作密切相关。在处理字符串时,选择正确的工具至关重要,因为不同的方法可能会对程序的性能产生显著影响。 首先,我们来看一下`...

    String和StringBuffer 的区别 .txt

    在Java编程语言中,`String`和`StringBuffer`是非常重要的两个类,它们分别用于处理不可变(immutable)和可变(mutable)字符串。理解这两个类之间的区别对于有效地管理和操作字符串至关重要。 #### 一、String...

    String与StringBuffer区别详解

    在Java中,处理字符串主要涉及到两个类:String和StringBuffer。这两个类虽然在功能上有许多相似之处,但它们在实现和性能上却有很大的差别。 首先我们来理解String。String类在Java中是不可变的,这意味着一旦一个...

Global site tag (gtag.js) - Google Analytics