java语言：String类的concat方法与StringBuffer类的append方法区别？内存状态？

Posted 2023-03-14

如：line1: "abc"+"def"+"ghi"
line2: new String("abc").concat("def").concat("ghi");
line3: new StringBuffer("abc").append("def").append("ghi");
上述三行代码的区别，尤其是在内存中的变换状态的区别？

首先我们先看几个概念：

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

2： +和concat操作，是先开辟一个要拼接的字符串的空间，在和老字符串一起拼接成一个新的字符串，所以在堆内存中是创建了三块空间的；

然后先来说1和2的区别：line1: 用的是+，+在底层是通过StringBuffer对象的append方法对字符串进行连接，但是他也并不是直接添加的，我们看看他开辟了几块空间？“abc”“def”“ghi”,刚开始开辟了三块堆内存空间，执行一次+,“abcdef”这是第四块内存空间，最后是最终结果“abcdefghi”开辟了第五块堆内存空间，然后其余的被回收。

line2:同样也是开辟了五块堆内存空间，concat()和+号的区别我们可以看下concat()源代码：

public String concat(String str) 
    int otherLen = str.length();
    if (otherLen == 0) 
        return this;
    
    int len = value.length;
    /*copyOf数组复制,copyOf()的第二个自变量指定要建立的新数组长度，
    如果新数组的长度超过原数组的长度，则保留为默认值null或0*/
    char buf[] = Arrays.copyOf(value, len + otherLen);
    //将字符从此字符串复制到目标字符数组,len为数组中的起始偏移量
    str.getChars(buf, len);
    return new String(buf, true);

我们可以看到concat()方法是通过copyOf(),和getChars();两个方法来拼接数组的。+在底层是通过StringBuffer对象的append方法对字符串进行连接。

最后是StringBuffer：StringBuffer使用时，只会开辟一块内存空间，使用append添加或delete删除其内容时，也是在这一块内存空间中并不会生成多余的空间。所以速度是比较快的而String 每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，对速度的影响一定是相当大的。

参考技术A String是内容不变的，调用String.concat实际上是创建了一个新串，这个新串的内容为原串连接了尾串；而StringBuffer.append是直接在原串上附加。
line1与line2差别不大，都是String操作，区别是，1是串在堆上操作，并没有创建任何新String，除结果外；而2曾创建过"abc"的副本对象，哪怕内容一样。 参考技术B "abc"+"def"+"ghi"拼字符串；
new String("abc").concat("def").concat("ghi");
是将指定字符串连接到此字符串的结尾。
如果参数字符串的长度为 0，则返回此 String 对象。否则，创建一个新的 String 对象，用来表示由此 String 对象表示的字符序列和参数字符串表示的字符序列连接而成的字符序列。

示例：

"cares".concat("s") returns "caress"
"to".concat("get").concat("her") returns "together"

参数：
str - 连接到此 String 结尾的 String。
返回：
一个字符串，它表示在此对象字符后连接字符串参数字符而成的字符。

new StringBuffer("abc").append("def").append("ghi");
StringBuffer的拼接。

内存的变化自己想想就清楚了！ok 参考技术C http://gceclub.sun.com.cn/Java_Docs/html/zh_CN/api/本回答被提问者采纳

java中String StringBuilder 和 StringBuffer的联系与区别

　　String作为java中最基本的类，担负着承载字符信息的作用。String具有不可变的final属性 , 这也决定了它对于在程序中传递信息的不可或缺性 。开发中，我们常常要对字符串进行拼接，这时我们会用到String对象重载的“+”操作符或concat(str)方法，也可以用StringBuilder、StringBuffer对象的append(str)方法来实现。

那么，String、StringBuilder、StringBuffer之间到底有什么联系和区别？

什么情况下分别适合使用这三个不同的类？

使用中需要注意哪些问题呢？

一 、String

1 . String对象是不可变的 ：String是个final类，所以它不可以被继承，它的值是不可改变的

2 . Sting对象不同的创建方式的区别：

　　.class字节码文件在被JVM加载时，常量（符号引用、字符串字面量等）会在方法区的常量池中存放。其中，源码中出现过的字符串字面常量会保存在CONSTANT_STRING_INFO常量表中，根据不同创建方式，会有不同的内容分配

　　1）字面常量方式创建的String变量　　　

1 String str1 = "abcd";
2 String str2 = "abcd";
3 System.out.println(str1==str2);//true

可见上面创建的两个String的引用str1和str2都指向了CONSTANT_STRING_INFO常量表中的（同一个拘留字符串）同一地址值，所以str1==str2返回true。这是因为该类在加载时，字符串常量被存放在CONSTANT_STRING_INFO常量表中，并且同一字面值的字符串常量只会保存一次（称为拘留字符串）。注意：这里并没有创建String对象，因为没有在堆中分配内存。

2)通过new关键字创建String对象

1 String str1 = new String("string");
2 String str2 = new String("string");
3 System.out.println(str1==str2);//false

此时，str1==str2返回false。首先，字节码在加载时，将“string”字符串常量存放到CONSTANT_STRING_INFO常量表中，所以上面语句中出现的“String”被放在常量表的同一位置；然后，在执行上面两条语句是，通过关键字new，分别在堆中创建了两个对象，并且两对象在堆中保存的值均为“string”；也就是说，内存中共有三处存有同一字符串值：常量表中的拘留字符串、str1指向的堆空间、str2指向的堆空间。

3)通过intern()方法创建的String“对象”

1 String str1 = new String("string");
2 String str2 = new String("string").intern();
3 System.out.pringln(str1==str2);//true

intern()方法的作用：1.当常量池中的字符串常量表中存在与“string”拘留字符串内容相同的字符串时，则直接返回这个拘留字符串地址值，赋值给str2，此时并没有创建新的对象；2.当常量池中的字符创常量表中没有“string”拘留字符串时，则把“string”添加到常量池并保存到字符串常量表中，成为拘留字符串，然后在堆中创建String对象并将对象的引用返回，此时有新的对象创建。此方法主要是为了避免重复创建字符串对象。

3 . String中重载 + 操作符的原理

我们都知道，在String重载的+操作符前后可以拼接其他内容，包括基本数据类型和引用数据类型，并且其他数据类型都会转化成String类型。

其实，重载+操作符实际上，都是创建了一个StringBuilder或StringBuffer对象，用append方法对字符串进行拼接，最后调用toString方法返回字符串。

需要注意 + 拼接字符串的两种情况 ：

1 String str1 = "str";
2 String str2 = "ing";
3 String str = str1 + str2;
4 String str1_2 = "string";
5 System.out.pringln(str == str1_2);//false

这里 + 拼接的str1、str2是两个字符串变量，所以首先创建StringBuilder/StringBuffer对象，append(str1).append(str2)把str1和str2拼接起来，最后通过toString()生成一个新的String对象并把引用返回，赋值给str。这里创建了新的对象，所以会返回false;

1 String str1 = "str" + "ing";
2 String str2 = "string";
3 System.out.pringln(str1 == str2);//true

使用 + 操作符拼接两个字符串字面量时，JVM会自动将这两部分字符串合并成完整的字符串常量值，保存到常量池的字符串常量表中成为拘留字符串。所以，这里只是将拘留字符串返回了而已，并没有创建新的对象。

4 . String类的concat(str)方法拼接字符串

只能将String类型的内容拼接到调用者后面，并不能像重载的+ 操作符那样拼接其他数据类型的内容。

 1 public String concat(String str) {      
 2 　　int otherLen = str.length();      
 3 　　if (otherLen == 0) {          
 4 　　　　return this;  
 5     }  
 6     char buf[] = new char[count + otherLen];  
 7     getChars(0, count, buf, 0);  
 8     str.getChars(0, otherLen, buf, count);  
 9     return new String(0, count + otherLen, buf);  
10}  

可以看到，concat(str)方法拼接字符串的原理是创建一个新的char[]字符数组，把两个字符串转化成char类型之后存放到数组中，最后用char[]数组创建一个新的String对象。

二 、StringBuilder

1 . StringBuilder是一个非线程安全的final类，不能被继承

2 . append(str)方法的原理

 1 public StringBuilder append(String str) {
 2     super.append(str);
 3     return this;
 4 }

调用了父类的append(str)方法：

 1   public AbstractStringBuilder append(String str) {
 2         if (str == null) {
 3             str = "null";
 4         }
 5         int len = str.length();
 6         if (len == 0) {
 7             return this;
 8         }
 9 
10         int newCount = count + len;//统计拼接后字符串长度
11         if (newCount > value.length) {
12             expandCapacity(newCount);//如果拼接结果大于所用的char[]，则扩容
13         }
14        //getChars将拼接字符串赋值到char[]中
15         str.getChars(0, len, value, count);
16         count = newCount;//更新char[]所保存的字符串长度
17         return this;
18     }

可知，用StringBuilder拼接字符串时，其实是在底层创建了一个char[]数组，然后通过char[]把要拼接的字符串添加到char[]而已。最后通过toString()生成最终拼接结果时就是通过  return new String(char[]) 实现的。

三 、StringBuffer

1 . StringBuffer是线程安全的final类，不能被继承

2 . append(str)方法

1 public synchronized StringBuffer append(String str) {
2     super.append(str);
3     return this;
4 }

可以看到，StringBuffer的append也是调用父类AbstractStringBuilder的append方法实现的，原理同StringBuilder。其唯一不同的地方在于，加了一个syncrhoized关键字修饰append（）方法，保证了线程同步。

四 、String、StringBuilder和StringBuffer性能比较与选用

1 . 性能：StringBuilder > StringBuffer > String

　　从上面四种（其实应该说是五种，+ 分为字符串常量的拼接和变量的拼接两种）的字符串拼接来看，除了字符串常量的拼接是返回拘留字符串的地址外，其他四种（str1+str2、str1.concat(str2)、builder.append(str1).append(str2)、buffer.append(str1).append(str2)）都是使用了StringBuilder，或者说是StringBuilder的父类的拼接方法来做的——创建一个char数组，把需要拼接的内容先存进char数组，最后通过char数组创建新的String对象返回。

            造成三者性能差别的主要原因是：

　　用String的 + 累加拼接字符串变量时，每拼接一个就会创建一个StringBuilder，并通过append()方法拼接，然后返回一个新的String对象。然后再继续拼接下一个变量。这样就会导致重复创建StringBuilder对象，性能低下。用 concat() 累计拼接时，则每两个字符串拼接都会创建一个 char[] 进行内容拼接并返回一个新的String对象作为结果，重复调用concat()会导致重复创建char[]和新String对象，性能低下。

　　StringBuilder在调用toString()之前都不会创建拼接结果，并且底层的char数组会自动扩容，一直到拼接字符串全部存入char数组后，调用toString()时才创建新的String对象并返回，这样就避免了重复创建，效率提高。

            　　StringBuffer则因为使用了syncrhoized对append()进行了加锁，所以导致性能稍微低于StringBuilder。

2 . 不同情境下的选用

拼接两个字符串字面量，用 + 操作符；

单线程下拼接两个字符串变量，用StringBuilder；  

多线程下拼接两个字符串变量，用StringBuffer 。