JAVA字符串拼接常见⽅法汇总
字符串的拼接，常使⽤到的⼤概有4种⽅式：
1.直接使⽤"+"号
2.使⽤String的concat⽅法
3.使⽤StringBuilder的append⽅法
4.使⽤StringBuffer的append⽅法
由于String是final类型的，因此String对象都是属于不可变对象，因此，在需要对字符串进⾏修改操作的时候（⽐如字符串的连接或者是替换），String总是会⽣成新的对象。
1.“+”
如果不考虑其他，使⽤“+”号来连接字符串⽆疑是最⽅便、最快捷的⽅式。但是事实上，使⽤“+”号连接字符串的效率并不⾼，。
贴出测试⽤的demo
public class Str {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "wolrd";
String str = str1 + str2;
System.out.println(str);
}
}
贴出Str通过编译之后产⽣的字节码⽂件
public class com.fzkj.str.Str {
public com.fzkj.str.Str();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: ldc #2 // String hello
2: astore_1
3: ldc #3 // String wolrd
5: astore_2字符串截取拼接
6: new #4 // class java/lang/StringBuilder
9: dup
10: invokespecial #5 // Method java/lang/StringBuilder."<init>":()V
13: aload_1
14: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
17: aload_2
18: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
21: invokevirtual #7 // Method java/String:()Ljava/lang/String;
24: astore_3
25: getstatic #8 // Field java/lang/System.out:Ljava/io/PrintStream;
28: aload_3
29: invokevirtual #9 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
32: return
}
通过上⾯的字节码⽂件可以看出，在执⾏String str = str1 + str2；这⼀条语句的时候，其实底层是调⽤了StringBuilder的append ⽅法来实现，就是说使⽤“+”号连接字符串的时候，底层会new⼀个StringBuilder对象，调⽤该对象的append⽅法将字符串拼接起来，最后通过toString⽅法返回拼接之后的值。
也就是字符串str1+str2就等效于下⾯的代码：
String str1 = "hello";
String str2 = "wolrd";
StringBuilder sb = new StringBuilder();
sb.append(str1).append(str2);
String s = sb.toString();
在数据量很⼤的时候，⽐如说循环⼀万次，那就会创建⼀万个StringBuilder对象。所以说使⽤"+"号拼接字符串的效率很低。最后在看⼀下使⽤"+"号拼接str1和str2，100000次的耗时。
public class Str {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "wolrd";
long startTime = System.currentTimeMillis();
System.out.println("开始执⾏时间："+ startTime);
for (int i = 0; i < 100000; i++) {
String str = str1 + str2;
}
long stopTime = System.currentTimeMillis();
System.out.println("结束执⾏时间："+ stopTime);
System.out.println("执⾏100000次字符串拼接总共耗时："+(stopTime - startTime)+"ms");
}
}
开始执⾏时间：1591326544582
结束执⾏时间：1591326544601
执⾏100000次字符串拼接总共耗时：19ms
concat源码如下：
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = pyOf(value, len + otherLen);
return new String(buf, true);
}
从concat⽅法的源码中可以看出来，concat就是申请了⼀个char数组，将需要拼接的字符串放到这个数组中，最后转换为String返回。
还是记录拼接100000次，总共的耗时
public class Str {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "wolrd";
// 使⽤concat连接字符串
String concat = at(str2);
long startTime = System.currentTimeMillis();
System.out.println("开始执⾏时间："+ startTime);
for (int i = 0; i < 100000; i++) {
String str = at(str2);
}
long stopTime = System.currentTimeMillis();
System.out.println("结束执⾏时间："+ stopTime);
System.out.println("执⾏100000次字符串拼接总共耗时："+(stopTime - startTime)+"ms");
}
}
开始执⾏时间：1591328017552
结束执⾏时间：1591328017561
执⾏100000次字符串拼接总共耗时：9ms
3.StringBuffer/StringBuilder
这两个类都继承了同⼀个抽象类AbstractStringBuilder；⽽这两个类的append⽅法都是调⽤的⽗类中的append⽅法。 public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
count += len;
return this;
}
⽽它俩的区别就是StringBuffer的append⽅法上加了synchronized关键字，因此是线程安全的。
public class Str {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "wolrd";
StringBuffer sb = new StringBuffer();
long startTime = System.currentTimeMillis();
System.out.println("开始执⾏时间："+ startTime);
for (int i = 0; i < 100000; i++) {
sb.append(str1);
}
long stopTime = System.currentTimeMillis();
System.out.println("结束执⾏时间："+ stopTime);
System.out.println("StringBuffer执⾏100000次字符串拼接总共耗时："+(stopTime - startTime)+"ms");
StringBuilder sb1 = new StringBuilder();
long startTime1 = System.currentTimeMillis();
System.out.println("开始执⾏时间："+ startTime1);
for (int i = 0; i < 100000; i++) {
sb1.append(str1);
}
long stopTime1 = System.currentTimeMillis();
System.out.println("结束执⾏时间："+ stopTime1);
System.out.println("StringBuilder执⾏100000次字符串拼接总共耗时："+(stopTime1 - startTime1)+"ms");
}
}
开始执⾏时间：1591328952926
结束执⾏时间：1591328952933
StringBuffer执⾏100000次字符串拼接总共耗时：7ms
开始执⾏时间：1591328952934
结束执⾏时间：1591328952936
StringBuilder执⾏100000次字符串拼接总共耗时：2ms
StringBuilder的性能⽐StringBuffer的性能要好点。
从上⾯的结果中，可以得出⼀个结论，那就是这四种的效率由快到慢依次是：
StringBudiler>StringBuffer>concat>+
事实上，在拼接的字符串很少的情况下，concat的效率其实是⽐StringBuilder的效率还要⾼的。
所以在实际的使⽤过程中，要根据⾃⼰的需求选择使⽤。。
以上就是JAVA字符串拼接常见⽅法汇总的详细内容，更多关于JAVA字符串拼接的资料请关注其它相关⽂章！
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论