Question

I read about the way Java works with += operator, using StringBuilder.
Is it the same with a ("a" + "b") operation?

Answer 1

页: 1 它使用<代码>StringBuilder而不是在a” +“b。

在 Java,强势是不可改变的。

因此,如果你:

String c = "a" + "b";

你们每次会聚在一起,都会创造新的优势。

另一方面,StingBuilder也像一个缓冲地带,它可以在评估新力量时增长。

StringBuilder c = new StringBuilder();
c.append("a");
c.append("b"); // c is only created once and appended "a" and "b".

umb(根据我的评论改动):

如果你会聚集一堂(即聚集一堂,或产生由几块坚固的加固变量组成的大型XML),那么实际上就使用StingBuilder。否则,简单分类(使用+经营者)将只是罚款。

汇编这种法典也发挥了巨大作用。

< 详见。

还有更多关于这一问题的StackOVerflow问题:

是否最好在休息室里重新使用“强硬”?

如何在贾瓦建造一系列有限物品?

StringBuilder vs String connation in toString (a>

Answer 2

如果将literalstrings (literally "foo” +“bar)合并起来,汇编者在汇编时,而不是在操作时间进行。

如果你有两条非诉讼地,并加入<条码>+,则汇编者(无论哪条)将使用封面的<条码>,但不一定是最有效的方式。例如,如果你有:

String repeat(String a, int count) {
    String rv;

    if (count <= 0) {
        return "";
    }

    rv = a;
    while (--count > 0) {
        rv += a;
    }
    return rv;
}

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 类似:

String repeat(String a, int count) {
    String rv;

    if (count <= 0) {
        return "";
    }

    rv = a;
    while (--count > 0) {
        rv = new StringBuilder().append(rv).append(a).toString();
    }
    return rv;
}

(事实上,见本答复结尾的解调)。) 请注意,它创建了一个新的<条码>每个条码的编码,然后将结果转换为<条码>。这是低效的(但除非你重新做lot),因为所有临时记忆分配都: 它分配了<条码>StringBuilder及其缓冲,很有可能在第一个<条码>上重新分配缓冲。 [如果rv 具有16个以上特性,即为缺漏的缓冲尺寸],如果没有,则在第二个<代码>适用<>/代码>上几乎肯定会出现这种情况,那么最终将分配一个<代码>String,然后在下一个版本上再分配。

如有必要,可以通过重新写法明确使用<代码>来提高效率。 StringBuilder:

String repeat(String a, int count) {
    StringBuilder rv;

    if (count <= 0) {
        return "";
    }

    rv = new StringBuilder(a.length() * count);
    while (count-- > 0) {
        rv.append(a);
    }
    return rv.toString();
}

我们在那里使用了明确的<代码>StringBuilder,并确定了其最初的缓冲能力,足以保持这一结果。这提高了记忆效率,但当然略微不太明显,没有经验的密码保持者,而且稍微增加了书写的痛苦。因此,if,你发现一个表现问题,有了一个紧凑的星座,这可能是解决这一问题的途径。

您可在与以下试验类别一起采取行动时看到这一次检查编码:

public class SBTest
{
    public static final void main(String[] params)
    {
        System.out.println(new SBTest().repeat("testing ", 4));
        System.exit(0);
    }

    String repeat(String a, int count) {
        String rv;

        if (count <= 0) {
            return "";
        }

        rv = a;
        while (--count > 0) {
            rv += a;
        }
        return rv;
    }
}

......解体(使用<条码>javap - c SB :)

Compiled from "SBTest.java"
public class SBTest extends java.lang.Object{
public SBTest();
Code:
   0: aload_0
   1: invokespecial  #1; //Method java/lang/Object."<init>":()V
   4: return

public static final void main(java.lang.String[]);
Code:
   0: getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   3: new   #3; //class SBTest
   6: dup
   7: invokespecial  #4; //Method "<init>":()V
   10: ldc   #5; //String testing
   12: iconst_4
   13: invokevirtual  #6; //Method repeat:(Ljava/lang/String;I)Ljava/lang/String;
   16: invokevirtual  #7; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   19: iconst_0
   20: invokestatic   #8; //Method java/lang/System.exit:(I)V
   23: return

java.lang.String repeat(java.lang.String, int);
Code:
   0: iload_2
   1: ifgt  7
   4: ldc   #9; //String
   6: areturn
   7: aload_1
   8: astore_3
   9: iinc  2, -1
   12: iload_2
   13: ifle  38
   16: new   #10; //class java/lang/StringBuilder
   19: dup
   20: invokespecial  #11; //Method java/lang/StringBuilder."<init>":()V
   23: aload_3
   24: invokevirtual  #12; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   27: aload_1
   28: invokevirtual  #12; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   31: invokevirtual  #13; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   34: astore_3
   35: goto  9
   38: aload_3
   39: areturn

}

请注意,如何在each上设立新的<代码>StringBuilder,并使用缺省缓冲能力创建。

所有这些临时拨款都很 sound,但是,如果你重新处理实质性的住宿和(或)实质性的扼杀,则再次出现。此外,在使用由此产生的星号时,证书制度可能大大优化。例如,Sun shotSpot JVER是一个非常成熟的JIT优化汇编器。一旦确定 lo为热点,它就很可能找到一种方式来重新证明它。当然不是:-

在我看到一个表现问题时,或者如果我知道我做一个“<>位置<>>/位置>的分类,并且它有很有可能成为业绩问题的<>,而且如果我使用“/code>,则从可维持的角度来看,该代码会受到严重影响。反预谋主义联盟可能不同意我关于其中第二点的意见。

Answer 3

是的,但汇编者可在发布守则之前进一步优化literals<>em>的分类,因此a”+”b。

Answer 4

为了压缩一个编号的固定编号和+,汇编者将使用一个<代码>StringBuilder制作代码。

E.g.线

String d = a + b + c;

结果是与行文相同的星码。

String d = new StringBuilder().append(a).append(b).append(c).toString();

使用javac汇编器汇编。 (Eclipse汇编商援引new StringBuilder(a),从而节省了一种方法电话,从而产生了一些更为优化的代码。)

如其他答复所述,汇编者将汇合如下字面,如<代码>a”+“b”,形成一个示意图,形成包含<代码>ab”的星码。

如在网点上提及的,你不应使用<代码>+,在座标/座标上架设一个座标的,因为你正在将座标的开始翻到新的座标上。在这种情况下,你应使用一份<代码>StringBuilder,在休息室外公布。

Answer 5

尽管可读、易于格式和直截了当,但加固“+”的阵列在 Java被认为是坏处。

Each time you append something via + (String.concat()) a new String is created, the old String content is copied, the new content is appended, and the old String is discarded. The bigger the String gets the longer it takes - there is more to copy and more garbage is produced. Note: if you are just concatenating a few (say 3,4) strings and not building a string via a loop or just writing some test application, you could still stick with "+"

缩略语

在进行广泛的操纵时(或通过假体进行评估),将“+”改为<代码>StringBuilder。在“+”情况下提及的中间物体不在<代码>append()方法使用期间生成。

还应当指出,Sun Java汇编器的优化,自动生成StringBuilders(StringBuffers < 5.0)在它看到了强类。但这只是 Sun的汇编者。

Answer 6

Strings are more commonly concatenated with the + operator, as in "Hello," + " world" + "!"

http://java.sun.com/docs/books/tutorial/java/data/strings.html> rel=“nofollow noreferer”>Source

友情链接