如何用String優化字符串？

發布時間：2020-05-29 12:49:01 來源：億速云閱讀：177 作者：Leah 欄目：編程語言

這篇文章主要為大家詳細介紹了String優化字符串的方法，文中方法步驟詳細，每個優化方案都有舉例展示，感興趣的小伙伴們可以參考一下。

一.優化構建的超大字符串

　　驗證環境：jdk1.8

　　反編譯工具：jad

1.下載反編譯工具jad，百度下載

2.驗證

先執行一段例子1代碼：

public class test3 {
    public static void main(String[] args) {
        String str="ab"+"cd"+"ef"+"123";
    }
}

執行完成后，用反編譯工具jad進行反編譯：jad -o -a -s d.java test.class

反編譯后的代碼：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) annotate 
// Source File Name:   test.java
package example;
public class test
{
    public test()
    {
    //    0    0:aload_0         
    //    1    1:invokespecial   #1   <Method void Object()>
    //    2    4:return          
    }
    public static void main(String args[])
    {
        String str = "abcdef123";
    //    0    0:ldc1            #2   <String "abcdef123">
    //    1    2:astore_1        
    //    2    3:return          
    }
}

案例2：

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

用反編譯工具jad執行jad -o -a -s d.java test1.class進行反編譯后：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) annotate 
// Source File Name:   test1.java

package example;

import java.io.PrintStream;

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

根據反編譯結果，可以看到內部其實是通過StringBuilder進行字符串拼接的。

再來執行例3的代碼：

public class test2 {
    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);
    }
}

用反編譯工具jad執行jad -o -a -s d.java test2.class進行反編譯后，發現其內部同樣是通過StringBuilder來進行拼接的：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) annotate 
// Source File Name:   test2.java
package example;
import java.io.PrintStream;
import java.util.Random;
public class test2
{
    public test2()
    {
    //    0    0:aload_0         
    //    1    1:invokespecial   #1   <Method void Object()>
    //    2    4:return          
    }
    public static void main(String args[])
    {
        String s = "";
    //    0    0:ldc1            #2   <String "">
    //    1    2:astore_1        
        Random rand = new Random();
    //    2    3:new             #3   <Class Random>
    //    3    6:dup             
    //    4    7:invokespecial   #4   <Method void Random()>
    //    5   10:astore_2        
        for(int i = 0; i < 10; i++)
    //*   6   11:iconst_0        
    //*   7   12:istore_3        
    //*   8   13:iload_3         
    //*   9   14:bipush          10
    //*  10   16:icmpge          55
            s = (new StringBuilder()).append(s).append(rand.nextInt(1000)).append(" ").toString();
    //   11   19:new             #5   <Class StringBuilder>
    //   12   22:dup             
    //   13   23:invokespecial   #6   <Method void StringBuilder()>
    //   14   26:aload_1         
    //   15   27:invokevirtual   #7   <Method StringBuilder StringBuilder.append(String)>
    //   16   30:aload_2         
    //   17   31:sipush          1000
    //   18   34:invokevirtual   #8   <Method int Random.nextInt(int)>
    //   19   37:invokevirtual   #9   <Method StringBuilder StringBuilder.append(int)>
    //   20   40:ldc1            #10  <String " ">
    //   21   42:invokevirtual   #7   <Method StringBuilder StringBuilder.append(String)>
    //   22   45:invokevirtual   #11  <Method String StringBuilder.toString()>
    //   23   48:astore_1        

    //   24   49:iinc            3  1
    //*  25   52:goto            13
        System.out.println(s);
    //   26   55:getstatic       #12  <Field PrintStream System.out>
    //   27   58:aload_1         
    //   28   59:invokevirtual   #13  <Method void PrintStream.println(String)>
    //   29   62:return          
    }
}

綜上案例分析，發現字符串進行“+”拼接時，內部有以下幾種情況：

1.“+”直接拼接的是常量變量，如"ab"+"cd"+"ef"+"123"，內部編譯就把幾個連接成一個常量字符串處理；

2. “+”拼接的含變量字符串，如案例2："ok" + s + "xyz" + 5，內部編譯其實是new 一個StringBuilder來進行來通過append進行拼接；

3.案例3循環過程，實質也是“+”拼接含變量字符串，因此，內部編譯時，也會創建StringBuilder來進行拼接。

對比三種情況，發現第三種情況每次做循環，都會新創建一個StringBuilder對象，這會增加系統的內存，反過來就會降低系統性能。

因此，在做字符串拼接時，單線程環境下，可以顯性使用StringBuilder來進行拼接，避免每循環一次就new一個StringBuilder對象；在多線程環境下，可以使用線程安全的StringBuffer，但涉及到鎖競爭，StringBuffer性能會比StringBuilder差一點。