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/lang/stringbuilder.tostring:()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

2.concat

concat源码如下：

  public string concat(string str) {
    int otherlen = str.length();
    if (otherlen == 0) {
      return this;
    }
    int len = value.length;
    char buf[] = arrays.copyof(value, len + otherlen);
    str.getchars(buf, len);
    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 = str1.concat(str2);
    long starttime = system.currenttimemillis();
    system.out.println("开始执行时间："+ starttime);
    for (int i = 0; i < 100000; i++) {
      string str = str1.concat(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);
    str.getchars(0, len, value, count);
    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字符串拼接的资料请关注其它相关文章！