如何用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差一点。