java中字符串相加本质到底是怎样的？

Question

String s="class"+"java";
操作机制应该是缓冲内存取得内容"class","java",然后存入一个新内存空间
跟原先字符串内存没关系

Answer 1

借宝地顶一下。请大家分辨一下，这个是不是传说中的“倒分”贴？
http://community.csdn.net/Expert/topic/3645/3645826.xml

Answer 2

Java 中唯一个系统级的运算符重载操作，就是字符串相加。

Answer 3

应该是后一种吧这是api中的原话The Java language provides special support for the string concatenation operator (  ), and for conversion of other objects to strings. String concatenation is implemented through the StringBuffer class and its append method. String conversions are implemented through the method toString, defined by Object and inherited by all classes in Java. For additional information on string concatenation and conversion, see Gosling, Joy, and Steele, The Java Language Specification.

Answer 4

如果是后一种的话，那是不是说，在重载实现过程中，还是要生成新的字符串对象？最终相当于实现为：
sb = sb.append("a").append("b").append("c");
但是这么解释，明显又不合理，因为这就与直接String s = "a" + "b" + "c";还是直接sb = sb.append("a").append("b").append("c");没有区别了，反正最终都是sb = sb.append("a").append("b").append("c");啊？

Answer 5

如果是后一种的话，那是不是说，在重载实现过程中，还是要生成新的字符串对象？
的确是新的内存空间,区别可能是sb = sb.append("a").append("b").append("c");这个是StringBuffer类的方法吧^_^

Answer 6

     在java内部的确是对+进行了重载，在处理String的过程中要创建一个StringBuffer对象，用StringBuffer对象的append方法对字符串进行连接，最后调用toString方法返回String字符串。

Answer 7

你懂StringBuffer吗？？？
String相加其实是先将其转换为StringBuffer。再相加。

Answer 8

String是final类型,但是StringBuffer不是;
生成新对象是肯定的,但是只有一个StringBuffer;
等操作完成后才将StringBuffer转换成String
中间生成了一个StringBuffer对象,一个String对象

Answer 9

String s = "a" + "b" + "c";
就等于String s = "abc";String a = "a";
String b = "b";
String c = "c";
String s = a + b + c;
这个就不一样了，好像最终结果类似于：
StringBuffer temp = new StringBuffer();
temp.append(a).append(b).append(c);
String s = temp.toString();

Answer 10

to zcjl() :
基本上，我现在的理解和你是一样的。但是疑问就在这里了，也是我的疑问。
如你上面说的那样，“＋”操作符被重载，以StringBuffer来实现了字符串的相加。但是论坛里也有很多讨论，关于什么时候使用字符串相加，什么时候使用StringBuffer，甚至有人说如果＋号超过4个的话，就用StringBuffer。那么现在的讨论结果，似乎是使用字符串相加，还是使用StringBuffer.append()无所谓了？反正最终还是使用StringBuffer来实现，来达到几个字符串连在一起的目的。
还有一点，论坛中有人讨论，似乎也证明了，在大量字符串相加的时候，其执行效率是远远低于StringBuffer的append的。

Answer 11

应该是第一种吧！就象zcjl说的

Answer 12

用bytecode来说明问题：1.使用String + 的方式：
public class Test2 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String c = "c";
        String s = a + b + c;
    }
}对应的bytecode为：public class Test2 extends java.lang.Object{
public Test2();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   returnpublic static void main(java.lang.String[]);
  Code:
   0:   ldc     #2; //String a
   2:   astore_1
   3:   ldc     #3; //String b
   5:   astore_2
   6:   ldc     #4; //String c
   8:   astore_3
   9:   new     #5; //class StringBuffer
   12:  dup
   13:  invokespecial   #6; //Method java/lang/StringBuffer."<init>":()V
   16:  aload_1
   17:  invokevirtual   #7; //Method java/lang/StringBuffer.append:(Ljava/lang/S
tring;)Ljava/lang/StringBuffer;
   20:  aload_2
   21:  invokevirtual   #7; //Method java/lang/StringBuffer.append:(Ljava/lang/S
tring;)Ljava/lang/StringBuffer;
   24:  aload_3
   25:  invokevirtual   #7; //Method java/lang/StringBuffer.append:(Ljava/lang/S
tring;)Ljava/lang/StringBuffer;
   28:  invokevirtual   #8; //Method java/lang/StringBuffer.toString:()Ljava/lan
g/String;
   31:  astore  4
   33:  return}2.使用StringBuffer.append()的方式：
public class Test3 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String c = "c";
        StringBuffer sb = new StringBuffer();
        sb.append(a).append(b).append(c);
        String s = sb.toString();
    }
}对应的bytecode为：public class Test3 extends java.lang.Object{
public Test3();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   returnpublic static void main(java.lang.String[]);
  Code:
   0:   ldc     #2; //String a
   2:   astore_1
   3:   ldc     #3; //String b
   5:   astore_2
   6:   ldc     #4; //String c
   8:   astore_3
   9:   new     #5; //class StringBuffer
   12:  dup
   13:  invokespecial   #6; //Method java/lang/StringBuffer."<init>":()V
   16:  astore  4
   18:  aload   4
   20:  aload_1
   21:  invokevirtual   #7; //Method java/lang/StringBuffer.append:(Ljava/lang/S
tring;)Ljava/lang/StringBuffer;
   24:  aload_2
   25:  invokevirtual   #7; //Method java/lang/StringBuffer.append:(Ljava/lang/S
tring;)Ljava/lang/StringBuffer;
   28:  aload_3
   29:  invokevirtual   #7; //Method java/lang/StringBuffer.append:(Ljava/lang/S
tring;)Ljava/lang/StringBuffer;
   32:  pop
   33:  aload   4
   35:  invokevirtual   #8; //Method java/lang/StringBuffer.toString:()Ljava/lan
g/String;
   38:  astore  5
   40:  return}看到了么？后者不光不比前者效率高，反而多了一些临时变量的存取

Answer 13

至于推荐用StringBuffer来代替String+拼装字符串，说的是循环方式下，如：public class Test4 {
    public static void main(String[] args) {
        String s = "s";
        for (int i = 0; i < 20; i++) {
            s += i;
        }
    }
}对应的bytecode为：public class Test4 extends java.lang.Object{
public Test4();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   returnpublic static void main(java.lang.String[]);
  Code:
   0:   ldc     #2; //String s
   2:   astore_1
   3:   iconst_0
   4:   istore_2
   5:   iload_2
   6:   bipush  20
   8:   if_icmpge       36
   11:  new     #3; //class StringBuffer
   14:  dup
   15:  invokespecial   #4; //Method java/lang/StringBuffer."<init>":()V
   18:  aload_1
   19:  invokevirtual   #5; //Method java/lang/StringBuffer.append:(Ljava/lang/S
tring;)Ljava/lang/StringBuffer;
   22:  iload_2
   23:  invokevirtual   #6; //Method java/lang/StringBuffer.append:(I)Ljava/lang
/StringBuffer;
   26:  invokevirtual   #7; //Method java/lang/StringBuffer.toString:()Ljava/lan
g/String;
   29:  astore_1
   30:  iinc    2, 1
   33:  goto    5
   36:  return}如果用String+的方式，每循环一次，就会重新new一个StringBuffer对象，这样的内存消耗完全是不必要的（在数据量大的情况下，还会导致内存不足的错误），所以要这样做：public class Test5 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("s");
        for (int i = 0; i < 20; i++) {
            sb.append(i);
        }
    }
}
这样无论循环多少次，都只会生成一个StringBuffer对象

Answer 14

那是不是说结论：
除非是在循环中，进行类似字符串相加操作，否则不需要考虑是用String，还是用StringBuffer？

Answer 15

插题外话
String s = "a" + "b" + "c";实际上编译出来是String s = "abc"；不存在相加问题实际上这种情况才会生成StringBuffer
String a = "a";
String b = "b";
String c = a+b;//<-生成了StringBuffer所以第一种问题不大，个人爱好问题，比如拼sql，有时候这样写看起来比较舒服
第二种是尽量不用的呵呵，题外话

Answer 16

String s = "a" + "b" + "c";
这里只有一个内存地址 S；String a = "a";
String b = "b";
String c = "c";
String s = a + b + c;
这里有四个内存地址，显然效率就不一样。