<rt id="bn8ez"></rt>
<label id="bn8ez"></label>

  • <span id="bn8ez"></span>

    <label id="bn8ez"><meter id="bn8ez"></meter></label>

    Java學習

    java,spring,structs,hibernate,jsf,ireport,jfreechart,jasperreport,tomcat,jboss -----本博客已經搬家了,新的地址是 http://www.javaly.cn 如果有對文章有任何疑問或者有任何不懂的地方,歡迎到www.javaly.cn (Java樂園)指出,我會盡力幫助解決。一起進步

     

    Java中連接字符串時是使用+號還是使用StringBuilder?

    字符串是Java程序中最常用的一種數據結構之一。在Java中的String類已經重載的"+"。也就是說,字符串可以直接使用"+"進行連接,如下面代碼所示:
                                                            

    String s = "abc" + "ddd";

        但這樣做真的好嗎?當然,這個問題不能簡單地回答yes or no。要根據具體情況來定。在Java中提供了一個StringBuilder類(這個類只在J2SE5及以上版本提供,以前的版本使用StringBuffer類),這個類也可以起到"+"的作用。

    那么我們應該用哪個呢?


    下面讓我們先看看如下的代碼:

    package string;
      
      
    public class TestSimplePlus
      {
          
    public static void main(String[] args)
          {
              String s 
    = "abc";
              String ss 
    = "ok" + s + "xyz" + 5;
              System.out.println(ss);
          }
      }

    上面的代碼將會輸出正確的結果。從表面上看,對字符串和整型使用"+"號并沒有什么區別,但事實真的如此嗎?下面讓我們來看看這段代碼的本質。

    我們首先使用反編譯工具(如jdk帶的javap、或jad)將TestSimplePlus反編譯成Java Byte Code,其中的奧秘就一目了然了。在本文將使用jad來反編譯,命令如下:

    jad -o -a -s d.java TestSimplePlus.class

    反編譯后的代碼如下:


    package string;

    import java.io.PrintStream;

    public class TestSimplePlus
    {
        
    public TestSimplePlus()
        {
        
    //    0    0:aload_0         
        
    //    1    1:invokespecial   #8   <Method void Object()>
        
    //    2    4:return          
        }

        
    public static void main(String args[])
        {
          String s 
    = "abc";
        
    //    0    0:ldc1            #16  <String "abc">
        
    //    1    2:astore_1        
          String ss = (new StringBuilder("ok")).append(s).append("xyz").append(5).toString();
        
    //    2    3:new             #18  <Class StringBuilder>
        
    //    3    6:dup             
        
    //    4    7:ldc1            #20  <String "ok">
        
    //    5    9:invokespecial   #22  <Method void StringBuilder(String)>
        
    //    6   12:aload_1         
        
    //    7   13:invokevirtual   #25  <Method StringBuilder StringBuilder.append(String)>
        
    //    8   16:ldc1            #29  <String "xyz">
        
    //    9   18:invokevirtual   #25  <Method StringBuilder StringBuilder.append(String)>
        
    //   10   21:iconst_5        
        
    //   11   22:invokevirtual   #31  <Method StringBuilder StringBuilder.append(int)>
        
    //   12   25:invokevirtual   #34  <Method String StringBuilder.toString()>
        
    //   13   28:astore_2        
          System.out.println(ss);
        
    //   14   29:getstatic       #38  <Field PrintStream System.out>
        
    //   15   32:aload_2         
        
    //   16   33:invokevirtual   #44  <Method void PrintStream.println(String)>
        
    //   17   36:return          
        }
    }

    讀者可能看到上面的Java字節碼感到迷糊,不過大家不必擔心。本文的目的并不是講解Java Byte Code,因此,并不用了解具體的字節碼的含義。

    使用jad反編譯的好處之一就是可以同時生成字節碼和源代碼。這樣可以進行對照研究。從上面的代碼很容易看出,雖然在源程序中使用了"+",但在編譯時仍然將"+"轉換成StringBuilder。因此,我們可以得出結論,Java中無論使用何種方式進行字符串連接,實際上都使用的是StringBuilder

    那么是不是可以根據這個結論推出使用"+"StringBuilder的效果是一樣的呢?這個要從兩個方面的解釋。如果從運行結果來解釋,那么"+"StringBuilder是完全等效的。但如果從運行效率和資源消耗方面看,那它們將存在很大的區別。


       
    當然,如果連接字符串行表達式很簡單(如上面的順序結構),那么"+"StringBuilder基本是一樣的,但如果結構比較復雜,如使用循環來連接字符串,那么產生的Java Byte Code就會有很大的區別。先讓我們看看如下的代碼:


     package string;
      
      
    import java.util.*;
      
      
    public class TestComplexPlus
      {
          
    public static void main(String[] args)
          {
              String s 
    = "";
              Random rand 
    = new Random();
              
    for (int i = 0; i < 10; i++)
              {
                  s 
    = s + rand.nextInt(1000+ " ";
              }
              System.out.println(s);
          }
      }

         上面的代碼返編譯后的Java Byte Code如下:


    package string;

    import java.io.PrintStream;
    import java.util.Random;

    public class TestComplexPlus
    {

        
    public TestComplexPlus()
        {
        
    //    0    0:aload_0         
        
    //    1    1:invokespecial   #8   <Method void Object()>
        
    //    2    4:return          
        }

        
    public static void main(String args[])
        {
            String s 
    = "";
        
    //    0    0:ldc1            #16  <String "">
        
    //    1    2:astore_1        
            Random rand = new Random();
        
    //    2    3:new             #18  <Class Random>
        
    //    3    6:dup             
        
    //    4    7:invokespecial   #20  <Method void Random()>
        
    //    5   10:astore_2        
            for(int i = 0; i < 10; i++)
        
    //*   6   11:iconst_0        
        
    //*   7   12:istore_3        
        
    //*   8   13:goto            49
             s = (new StringBuilder(String.valueOf(s))).append(rand.nextInt(1000)).append(" ").toString();
        
    //    9   16:new             #21  <Class StringBuilder>
        
    //   10   19:dup             
        
    //   11   20:aload_1         
        
    //   12   21:invokestatic    #23  <Method String String.valueOf(Object)>
        
    //   13   24:invokespecial   #29  <Method void StringBuilder(String)>
        
    //   14   27:aload_2         
        
    //   15   28:sipush          1000
        
    //   16   31:invokevirtual   #32  <Method int Random.nextInt(int)>
        
    //   17   34:invokevirtual   #36  <Method StringBuilder StringBuilder.append(int)>
        
    //   18   37:ldc1            #40  <String " ">
        
    //   19   39:invokevirtual   #42  <Method StringBuilder StringBuilder.append(String)>
        
    //   20   42:invokevirtual   #45  <Method String StringBuilder.toString()>
        
    //   21   45:astore_1        

        
    //   22   46:iinc            3  1
        
    //   23   49:iload_3         
        
    //   24   50:bipush          10
        
    //   25   52:icmplt          16
            System.out.println(s);
        
    //   26   55:getstatic       #49  <Field PrintStream System.out>
        
    //   27   58:aload_1         
        
    //   28   59:invokevirtual   #55  <Method void PrintStream.println(String)>
        
    //   29   62:return          
        }
    }

        大家可以看到,雖然編譯器將"+"轉換成了StringBuilder,但創建StringBuilder對象的位置卻在for語句內部。這就意味著每執行一次循環,就會創建一個StringBuilder對象(對于本例來說,是創建了10StringBuilder對象),雖然Java有垃圾回收器,但這個回收器的工作時間是不定的。如果不斷產生這樣的垃圾,那么仍然會占用大量的資源。解決這個問題的方法就是在程序中直接使用StringBuilder來連接字符串,代碼如下:

    package string;

    import java.util.*;

    public class TestStringBuilder
    {
        
    public static void main(String[] args)
        {
            String s 
    = "";
            Random rand 
    = new Random();
            StringBuilder result 
    = new StringBuilder();
            
    for (int i = 0; i < 10; i++)
            {
                result.append(rand.nextInt(
    1000));
                result.append(
    " ");
            }
            System.out.println(result.toString());
        }
    }

    上面代碼反編譯后的結果如下:


    package string;

    import java.io.PrintStream;
    import java.util.Random;

    public class TestStringBuilder
    {

        
    public TestStringBuilder()
        {
        
    //    0    0:aload_0         
        
    //    1    1:invokespecial   #8   <Method void Object()>
        
    //    2    4:return          
        }

        
    public static void main(String args[])
        {
            String s 
    = "";
        
    //    0    0:ldc1            #16  <String "">
        
    //    1    2:astore_1        
            Random rand = new Random();
        
    //    2    3:new             #18  <Class Random>
        
    //    3    6:dup             
        
    //    4    7:invokespecial   #20  <Method void Random()>
        
    //    5   10:astore_2        
            StringBuilder result = new StringBuilder();
        
    //    6   11:new             #21  <Class StringBuilder>
        
    //    7   14:dup             
        
    //    8   15:invokespecial   #23  <Method void StringBuilder()>
        
    //    9   18:astore_3        
            for(int i = 0; i < 10; i++)
        
    //*  10   19:iconst_0        
        
    //*  11   20:istore          4
        
    //*  12   22:goto            47
            {
                result.append(rand.nextInt(
    1000));
        
    //   13   25:aload_3         
        
    //   14   26:aload_2         
        
    //   15   27:sipush          1000
        
    //   16   30:invokevirtual   #24  <Method int Random.nextInt(int)>
        
    //   17   33:invokevirtual   #28  <Method StringBuilder StringBuilder.append(int)>
        
    //   18   36:pop             
                result.append(" ");
        
    //   19   37:aload_3         
        
    //   20   38:ldc1            #32  <String " ">
        
    //   21   40:invokevirtual   #34  <Method StringBuilder StringBuilder.append(String)>
        
    //   22   43:pop             
            }

        
    //   23   44:iinc            4  1
        
    //   24   47:iload           4
        
    //   25   49:bipush          10
        
    //   26   51:icmplt          25
            System.out.println(result.toString());
        
    //   27   54:getstatic       #37  <Field PrintStream System.out>
        
    //   28   57:aload_3         
        
    //   29   58:invokevirtual   #43  <Method String StringBuilder.toString()>
        
    //   30   61:invokevirtual   #47  <Method void PrintStream.println(String)>
        
    //   31   64:return          
        }
    }

    從上面的反編譯結果可以看出,創建StringBuilder的代碼被放在了for語句外。雖然這樣處理在源程序中看起來復雜,但卻換來了更高的效率,同時消耗的資源也更少了。

    在使用StringBuilder時要注意,盡量不要"+"StringBuilder混著用,否則會創建更多的StringBuilder對象,如下面代碼所:

        for (int i = 0; i < 10; i++)
        {
            result.append(rand.nextInt(
    1000));
            result.append(
    " ");
        }

    改成如下形式:

    for (int i = 0; i < 10; i++)
    {
         result.append(rand.nextInt(
    1000+ " ");
    }

    則反編譯后的結果如下:


    ......
       
    for(int i = 0; i < 10; i++)
      
    //*  10   19:iconst_0        
      
    //*  11   20:istore          4
      
    //*  12   22:goto            65
       {
        result.append((
    new StringBuilder(String.valueOf(rand.nextInt(1000)))).append(" ").toString());
      
    //   13   25:aload_3         
      
    //   14   26:new             #21  <Class StringBuilder>
      
    //   15   29:dup             
      ......

    從上面的代碼可以看出,Java編譯器將"+"編譯成了StringBuilder,這樣for語句每循環一次,又創建了一個StringBuilder對象。
       
    如果將上面的代碼在JDK1.4下編譯,必須將StringBuilder改為StringBuffer,而JDK1.4"+"轉換為StringBuffer(因為JDK1.4并沒有提供StringBuilder類)。StringBufferStringBuilder的功能基本一樣,只是StringBuffer是線程安全的,而StringBuilder不是線程安全的。因此,StringBuilder的效率會更高。


    來源:http://www.java3z.com/cwbwebhome/article/article2/21087.html?id=1877

    posted on 2008-07-15 16:47 找個美女做老婆 閱讀(289) 評論(0)  編輯  收藏


    只有注冊用戶登錄后才能發表評論。


    網站導航:
     

    導航

    統計

    公告

    本blog已經搬到新家了, 新家:www.javaly.cn
     http://www.javaly.cn

    常用鏈接

    留言簿(6)

    隨筆檔案

    文章檔案

    搜索

    最新評論

    閱讀排行榜

    評論排行榜

    主站蜘蛛池模板: 亚洲国产成人久久综合一 | 国产精成人品日日拍夜夜免费| 国产嫩草影院精品免费网址| 在线aⅴ亚洲中文字幕| 9420免费高清在线视频| 亚洲国产精品不卡在线电影| 久久久久国产免费| 亚洲黄色免费电影| 91麻豆国产免费观看| 亚洲成人黄色在线观看| 免费下载成人电影| 亚洲熟妇久久精品| 国产免费观看网站| 4hu四虎免费影院www| 亚洲精品无码MV在线观看| 久久香蕉国产线看免费| 亚洲激情视频网站| 好爽…又高潮了毛片免费看| 麻豆亚洲AV成人无码久久精品 | 亚洲国产主播精品极品网红| 日亚毛片免费乱码不卡一区| 国产亚洲精品国产| 亚洲视频在线免费看| 亚洲欧美成人av在线观看| 亚洲AV成人潮喷综合网| 成人性生交大片免费看中文| 亚洲永久中文字幕在线| 午夜免费福利在线| 国产精品免费在线播放| 亚洲精品欧洲精品| 国产高清在线精品免费软件| 国产精品免费观看视频| 久久亚洲国产精品成人AV秋霞| 人禽杂交18禁网站免费| 一级毛片无遮挡免费全部| 久久久久亚洲精品日久生情| 国产无遮挡吃胸膜奶免费看视频| 在线涩涩免费观看国产精品| 在线aⅴ亚洲中文字幕| 亚洲理论电影在线观看| 成熟女人特级毛片www免费|