Java字符串之String与StringBuilder

String与SringBuiler的一些比较

  在Java中，我们会大量使用字符串，但是String究竟是怎样工作的我们可能没有想过太多，其实在String类中，每一个看起来会修改String值的方法都是创建了一个全新的String对象。
  我们可以想想，在使用+连接字符串的时候究竟发生了什么，先看一段代码。

public class Test2
{
    public String method1(String[] fields)
    {
        String result = "";
        for(int i = 0; i < fields.length; i++)
        {
            result += fields[i];
        }

        return result;
    }

    public String method2(String[] fields)
    {
        StringBuilder result = new StringBuilder();
        for(int i = 0; i < fields.length; i++)
        {
            result.append(fields[i]);
        }

        return result.toString();
    }

    public String method3()
    {
        String result = "aa" + "bb" + "cc";

        return result;
    }

    public static void main(String[] args)
    {
        Test2 test = new Test2();
        String[] str = {"a", "b", "c", "d", "e", "f", "g"};
        System.out.println(test.method1(str));
        System.out.println(test.method2(str));
        System.out.println(test.method3());
    }
}

  上面代码中method1是使用+来连接字符串，而method2中使用了StringBuilder的append方法来连接字符串。使用javap命令来对代码进行反汇编。

public java.lang.String method1(java.lang.String[]);
Code:
0: ldc #2 // String
2: astore_2
3: iconst_0
4: istore_3
5: iload_3
6: aload_1
7: arraylength
8: if_icmpge 38
11: new #3 // class java/lang/StringBuilder
14: dup
15: invokespecial #4 // Method java/lang/StringBuilder.""😦)V
18: aload_2
19: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
22: aload_1
23: iload_3
24: aaload
25: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: invokevirtual #6 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
31: astore_2
32: iinc 3, 1
35: goto 5
38: aload_2
39: areturn

public java.lang.String method2(java.lang.String[]);
Code:
0: new #3 // class java/lang/StringBuilder
3: dup
4: invokespecial #4 // Method java/lang/StringBuilder.""😦)V
7: astore_2
8: iconst_0
9: istore_3
10: iload_3
11: aload_1
12: arraylength
13: if_icmpge 30
16: aload_2
17: aload_1
18: iload_3
19: aaload
20: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
23: pop
24: iinc 3, 1
27: goto 10
30: aload_2
31: invokevirtual #6 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
34: areturn

public java.lang.String method3();
Code:
0: ldc #7 // String aabbcc
2: astore_1
3: aload_1
4: areturn

  可以看到，在method1的8到35行是一个循环体，当我们使用+来连接String的时候，其实编译器调用了StringBuilder的append方法，因为它更高效，但是在这个循环体中，每一次循环都创建了一个StringBuilder对象，造成了资源的浪费。
  在method2中，可以看到13到27行是一个循环体，在method2中只创建了一个StringBuilder对象，节约了资源。
  在method3中，仅仅是三个字符串相加，最后可以看到，编译器对此进行了优化，直接生成了一个aabbcc字符串。
  在使用字符串的时候，就要注意着一些，在大量操作字符串的时候就应该考虑使用StringBuilder和StringBuffer，StringBuffer是线程安全的，因此开销也会更大一些。

• 少量数据使用String
• 单线程操作大量数据使用StringBuilder
• 多线程下操作大量数据使用StringBuffer

  接着说一个字符串比较问题，也跟以上的过程有关，先看一段代码。

public class Test3
{
    public static void main(String[] args)
    {
        String str1 = "HelloWorld";
        String str2 = "World";
        String str3 = "Hello" + str2;
        String str4 = "Hello" + "World";

        System.out.println(str1 == str3);
        System.out.println(str1 == str4);
    }
}

  这段代码的输出结果为:

false
true

  之所以会有这样的结果，是因为str3其实是编译器先new了一个StringBuilder对象，然后进行append，最后调用了toString()方法，而str4经过编译器优化，直接生成一个HelloWorld字符串，所以结果自然为true了。

0: ldc #2 // String HelloWorld
2: astore_1
3: ldc #3 // String World
5: astore_2
6: new #4 // class java/lang/StringBuilder
9: dup
10: invokespecial #5 // Method java/lang/StringBuilder.""😦)V
13: ldc #6 // String Hello
15: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
18: aload_2
19: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
22: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
25: astore_3
26: ldc #2 // String HelloWorld

  以上为这段代码的部分反汇编，可以从中看到每个字符串的生成过程，就不难理解上面的比较问题了。