常用的字符串拼接方式性能分析以及源码分析

最新推荐文章于 2023-10-27 13:48:31 发布
最新推荐文章于 2023-10-27 13:48:31 发布
阅读量329 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsy1072/article/details/107300352
版权

性能测试

在日常开发中，常用的字符串拼接主要有String +、String.concat、StringBuffer.append以及StringBuilder.append等四种。接下来我们测试一下这四种方式的性能到底哪个强。

  • 背景：对字符串进行5000次的拼接操作。
  • 运行环境：
  • CPU：2.4 GHz 四核Intel Core i5
  • 内存：16G
  • 系统：macOS 10.15.5
  • jdk:1.8.0_211
  • 测试工具：junitPerf

1.String +

    //String +
    @Test
    @JunitPerfConfig(threads = 1,warmUp = 1000,duration = 2000)
    public void stringDemo(){

        String string = "";
        for (int i = 0; i < BASE_NUM; i++) {
            string += "123";
        }

    }

2.String.concat

   //String concat
    @Test
    @JunitPerfConfig(threads = 1,warmUp = 1000,duration = 2000)
    public void stringConcatDemo(){

        String string = "";
        for (int i = 0; i < BASE_NUM; i++) {
            string = string.concat("123");
        }

    }

3.StringBuffer.append

    //StringBuffer append
    @Test
    @JunitPerfConfig(threads = 1,warmUp = 1000,duration = 2000)
    public void stringBufferDemo(){

        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < BASE_NUM; i++) {
            stringBuffer.append("123");
        }

    }

4.StringBuuilder.append

    //StringBuilder append
    @Test
    @JunitPerfConfig(threads = 1,warmUp = 1000,duration = 2000)
    public void stringBuilderDemo(){

        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < BASE_NUM; i++) {
            stringBuilder.append("123");
        }

    }

测试结果：
1.String +

[INFO] [2020-07-12 14:45:52.655] [c.l.a.s.Demo.stringDemo] - --------------------------------------------------------
[INFO] [2020-07-12 14:45:52.656] [c.l.a.s.Demo.stringDemo] - Started at:  2020-07-12 14:45:50.590
[INFO] [2020-07-12 14:45:52.656] [c.l.a.s.Demo.stringDemo] - Invocations:  124
[INFO] [2020-07-12 14:45:52.656] [c.l.a.s.Demo.stringDemo] - Success:  124
[INFO] [2020-07-12 14:45:52.657] [c.l.a.s.Demo.stringDemo] - Errors:  0
[INFO] [2020-07-12 14:45:52.657] [c.l.a.s.Demo.stringDemo] - Thread Count:  1
[INFO] [2020-07-12 14:45:52.657] [c.l.a.s.Demo.stringDemo] - Warm up:  1000ms
[INFO] [2020-07-12 14:45:52.658] [c.l.a.s.Demo.stringDemo] - Execution time:  2000ms
[INFO] [2020-07-12 14:45:52.658] [c.l.a.s.Demo.stringDemo] - Throughput:  124/s (Required: -1/s) - PASSED
[INFO] [2020-07-12 14:45:52.658] [c.l.a.s.Demo.stringDemo] - Memory cost:  16byte
[INFO] [2020-07-12 14:45:52.664] [c.l.a.s.Demo.stringDemo] - Min latency:  7.164541ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:45:52.665] [c.l.a.s.Demo.stringDemo] - Max latency:  115.50648ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:45:52.665] [c.l.a.s.Demo.stringDemo] - Avg latency:  16.036825ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:45:52.665] [c.l.a.s.Demo.stringDemo] - --------------------------------------------------------

2.String.concat

[INFO] [2020-07-12 14:47:12.577] [c.l.a.s.Demo.stringConcatDemo] - --------------------------------------------------------
[INFO] [2020-07-12 14:47:12.578] [c.l.a.s.Demo.stringConcatDemo] - Started at:  2020-07-12 14:47:10.535
[INFO] [2020-07-12 14:47:12.578] [c.l.a.s.Demo.stringConcatDemo] - Invocations:  192
[INFO] [2020-07-12 14:47:12.578] [c.l.a.s.Demo.stringConcatDemo] - Success:  192
[INFO] [2020-07-12 14:47:12.579] [c.l.a.s.Demo.stringConcatDemo] - Errors:  0
[INFO] [2020-07-12 14:47:12.579] [c.l.a.s.Demo.stringConcatDemo] - Thread Count:  1
[INFO] [2020-07-12 14:47:12.579] [c.l.a.s.Demo.stringConcatDemo] - Warm up:  1000ms
[INFO] [2020-07-12 14:47:12.580] [c.l.a.s.Demo.stringConcatDemo] - Execution time:  2000ms
[INFO] [2020-07-12 14:47:12.580] [c.l.a.s.Demo.stringConcatDemo] - Throughput:  192/s (Required: -1/s) - PASSED
[INFO] [2020-07-12 14:47:12.581] [c.l.a.s.Demo.stringConcatDemo] - Memory cost:  16byte
[INFO] [2020-07-12 14:47:12.586] [c.l.a.s.Demo.stringConcatDemo] - Min latency:  6.198077ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:47:12.587] [c.l.a.s.Demo.stringConcatDemo] - Max latency:  32.883385ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:47:12.587] [c.l.a.s.Demo.stringConcatDemo] - Avg latency:  10.378245ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:47:12.587] [c.l.a.s.Demo.stringConcatDemo] - --------------------------------------------------------

3.StringBuffer.append

[INFO] [2020-07-12 14:47:34.747] [c.l.a.s.Demo.stringBufferDemo] - --------------------------------------------------------
[INFO] [2020-07-12 14:47:34.748] [c.l.a.s.Demo.stringBufferDemo] - Started at:  2020-07-12 14:47:32.698
[INFO] [2020-07-12 14:47:34.748] [c.l.a.s.Demo.stringBufferDemo] - Invocations:  53224
[INFO] [2020-07-12 14:47:34.748] [c.l.a.s.Demo.stringBufferDemo] - Success:  53224
[INFO] [2020-07-12 14:47:34.749] [c.l.a.s.Demo.stringBufferDemo] - Errors:  0
[INFO] [2020-07-12 14:47:34.749] [c.l.a.s.Demo.stringBufferDemo] - Thread Count:  1
[INFO] [2020-07-12 14:47:34.749] [c.l.a.s.Demo.stringBufferDemo] - Warm up:  1000ms
[INFO] [2020-07-12 14:47:34.749] [c.l.a.s.Demo.stringBufferDemo] - Execution time:  2000ms
[INFO] [2020-07-12 14:47:34.750] [c.l.a.s.Demo.stringBufferDemo] - Throughput:  53224/s (Required: -1/s) - PASSED
[INFO] [2020-07-12 14:47:34.750] [c.l.a.s.Demo.stringBufferDemo] - Memory cost:  16byte
[INFO] [2020-07-12 14:47:34.757] [c.l.a.s.Demo.stringBufferDemo] - Min latency:  0.024695ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:47:34.759] [c.l.a.s.Demo.stringBufferDemo] - Max latency:  4.160009ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:47:34.761] [c.l.a.s.Demo.stringBufferDemo] - Avg latency:  0.037200477ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:47:34.761] [c.l.a.s.Demo.stringBufferDemo] - --------------------------------------------------------

4.StringBuilder.append


[INFO] [2020-07-12 14:48:08.912] [c.l.a.s.Demo.stringBuilderDemo] - --------------------------------------------------------
[INFO] [2020-07-12 14:48:08.913] [c.l.a.s.Demo.stringBuilderDemo] - Started at:  2020-07-12 14:48:06.865
[INFO] [2020-07-12 14:48:08.913] [c.l.a.s.Demo.stringBuilderDemo] - Invocations:  53838
[INFO] [2020-07-12 14:48:08.913] [c.l.a.s.Demo.stringBuilderDemo] - Success:  53838
[INFO] [2020-07-12 14:48:08.914] [c.l.a.s.Demo.stringBuilderDemo] - Errors:  0
[INFO] [2020-07-12 14:48:08.914] [c.l.a.s.Demo.stringBuilderDemo] - Thread Count:  1
[INFO] [2020-07-12 14:48:08.914] [c.l.a.s.Demo.stringBuilderDemo] - Warm up:  1000ms
[INFO] [2020-07-12 14:48:08.915] [c.l.a.s.Demo.stringBuilderDemo] - Execution time:  2000ms
[INFO] [2020-07-12 14:48:08.915] [c.l.a.s.Demo.stringBuilderDemo] - Throughput:  53838/s (Required: -1/s) - PASSED
[INFO] [2020-07-12 14:48:08.915] [c.l.a.s.Demo.stringBuilderDemo] - Memory cost:  16byte
[INFO] [2020-07-12 14:48:08.924] [c.l.a.s.Demo.stringBuilderDemo] - Min latency:  0.024493ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:48:08.926] [c.l.a.s.Demo.stringBuilderDemo] - Max latency:  4.138278ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:48:08.928] [c.l.a.s.Demo.stringBuilderDemo] - Avg latency:  0.0367233ms (Required: -1.0ms) - PASSED
[INFO] [2020-07-12 14:48:08.928] [c.l.a.s.Demo.stringBuilderDemo] - --------------------------------------------------------
  • 从测试结果可以看出，在拼接性能上StringBuilder.append > StringBuffer.append >> String.concat > String +。

源码分析

虽然我们得出了结论，那为什么会这样的？接下来我们从源码上分析。

  1. 首先，我们先分析一下“+”，其实“+”是一个语法糖，要知道它底层是怎么实现的，就要借助反编译工具了。
  • 反编译工具：crf

对stringDemo方法进行反编译之后的代码。

java -jar cfr-0.150.jar ./Demo.class --methodname stringDemo  --stringbuilder false

@Test
@JunitPerfConfig(threads=1, warmUp=1000L, duration=2000L)
public void stringDemo() {
    String string = "";
    for (int i = 0; i < 5000; ++i) {
        string = new StringBuilder().append(string).append("123").toString();
    }
}

可以看出，“+”其实是new StringBuilder，然后调用的appen(),也就是说，每进行一次拼接，就要new 一个StringBuilder对象，这是多么大的消耗啊！所以“+”进行拼接性能是最差的。

  1. 然后对String.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会创建一个已有字符串和带拼接字符串长度之和的数组，并将两个数组复制到新数组，在用新数组创建一个String对象。创建String对象保证的字符串的不可变性，为什么？因为String中的char[]使用final修饰的。
image.png

3.接下来就是append了，StringBuffer和StringBuilder的实现原理相似，不同在于StringBuffer的append方法用synchronized修饰，而StringBuilder没有。这就是为什么StringBuffer是线程安全，而StringBuilder不是线程安全的原因了，所以说StringBuilder.append性能会比StringBuffer.append好一点点。

StringBuffer.append

    @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

StringBuilder.append

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

继续分析，StringBuffer和StringBuilder都是可变的字符串，他们都继承AbstractStringBuilder，而AbstractStringBuilder 的成员数组char[]是没有final修饰的。
image.png

在拼接过程中，char[]会根据已有字符串长度和带拼接字符串长度进行扩容，然后再将数组复制到成员数组中（char [] value）

    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;
    }

    public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
	//拷贝数组操作
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }

分析源码后可以发现，StringBuffer和StringBuilder的append过程中，并没有创建对象，而是更加底层的数组操作，这就是为什么性能高的原因了。

总结

拼接方式这么多，而且性能差别这么大，在使用上有什么要注意的呢？
1.对于少量的拼接操作，用+（在拼接次数不多的情况下，性能差距不明显，怎么方便怎么来）
2.在for循环（大量拼接操作）下使用StringBuffer或者StringBuilder
3.并发场景下使用StringBuffer（线程安全）。

– from 常用的字符串拼接方式性能分析以及源码分析

北岭山下
关注
专栏目录
Java 8 中的字符串拼接新方式
简简单单Onlinezuozuo
03-25 6494
文章目录Java 8 中的字符串拼接新方式1、起因2、使用IDEA 提供的字符串拼接策略3、StringJoiner 介绍4、用法5、原理6、StringJoiner 分析 Java 8 中的字符串拼接新方式 1、起因 看过阿里的手册说不要再for 循环中使用+ 进行字符串拼接，除了比较常见的哪几种拼接方式和优缺点，还有一个比较重要的但是不怎么常用的方式。那就是Java 8的StringJoin...
Java进阶之光！java字符串拼接换行
m0_57286518的博客
07-19 2173
工作的前两年 如果你不能拼爹，或者不想拼爹，最好的方法是拼实力。 合抱之木，生于毫末；九层之台，起于垒土；千里之行，始于足下。 所以，你必须要从基层做起。当然，所谓的基层，并不是端茶倒水，但多一些体验，总是无害的。 前两年的时间，应当主要打好基础的累积，认清职业现状和社会经济发展趋势，适应工作后的生活，对心灵浮躁的洗涤。 这一阶段最大的敌人是自身的态度，切忌不可眼高手低，牢记一句话——“心比天高，命比纸薄。”脚踏实地，一步一个脚印，为未来做好铺垫。 工作的选择 对于应届生、刚毕业两年内的职场新人，我个人
字符串的拼接（C语言代码）
03-14
写函数mystrcat(char *t,char *s)，将串s连至串t之后。用指针形式。不可调用string.h里的strcat函数。 写程序，输入两个串，调用mystrcat函数将它们连接，输出连接后的串。
字符串拼接性能及其原理
qq_42170897的博客
03-31 479
go 字符串是不可修改的，所谓字符串拼接就是创建新的字符串对象。如果代码中存在大量的字符串拼接，那么性能将会存在影响。
字符串拼接性能比较
哒哒哒
06-14 808
话不多说直接上代码看一下拼接方法差异let arr = []; //数组有若干字符串 for(let i=0;i&lt;100000;i++){ arr.push(i+'A'); } //性能计算原理 //主要看同样遍历次数下时间消耗对比 function add1(){ let str = null; let start_time = new Date().getTime(); for...
三大类库（一）之字符串性能分析
aimolia8633的博客
07-08 92
一、分析 String类字符串追加 　　当我们对字符串进行拼接时，String:是对象不是原始类型.为不可变对象,一旦被创建,就不能修改它的值.对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.String 是sealed 类,即不能被继承. 　 string是String类的别名，引用类型，且该类型是只读的，不可修改，当你修改字符串内容时...
简单易懂源码解析字符串拼接
...
08-25 118
字符串拼接 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title
关于 Java 字符串拼接的几种方式以及性能比较
游戏建模零基础入门教程
05-04 2933
一、字符串拼接 字符串拼接是我们在Java代码中比较经常要做的事情，就是把多个字符串拼接到一起。 我们都知道，String 是 Java 中一个不可变的类，所以他一旦被实例化就无法被修改。 不可变类的实例一旦创建，其成员变量的值就不能被修改。这样设计有很多好处，比如可以缓存 hashcode、使用更加便利以及更加安全等。 但是，既然字符串是不可变的，那么字符串拼接又是怎么回事呢？ 1...
深入解析C语言字符串拼接源码项目案例
资源摘要信息:"本资源包含了C语言字符串拼接函数的源码以及相关的VC++学习资料。这些源码文件是学习C语言和VC++编程的良好示例，可用于理解C语言中字符串处理的实战应用。文件中涉及的编程项目包括VC++编程环境下的...
java中拼接字符串的5种方法效率对比
08-28
今天，我们将通过测试和分析，比较 Java 中 5 种不同的字符串拼接方法的效率，并探究每种方法背后的实现原理。 第一种方法：使用 + 运算符 在 Java 中，我们可以使用 + 运算符来拼接字符串。这是最简单的方法，但其...
几种拼接字符串的效率问题
amork的专栏
06-29 6884
 拼接字符串，大致有3个class可以用，他们是String, StringBuffer,StringBuilder, StringBuilder是1.5中来代替StringBuffer的。检验方法如下：   public class test { /** * @param args */ public static void main(String[] args)
5种字符串拼接方式的效率比拼
最新发布
浩浩的博客
10-27 1093
5种字符串拼接方式的效率比拼
go拼接字符串性能对比
u012189747的博客
06-21 255
测试对比： bytes.buffer和builder性能差不多 数组strings.Join性能次之 fmt.Springf性能最差，而且随着字符串越大，性能越差，适合小字符串拼接。
Go语言 字符串拼接性能优化
weixin_34273481的博客
09-12 308
今天在查找Go资料的时候，偶然中在点进看云中的《Go入门指南》这本书，简单的看了下书中的内容，然后看到有一节内容是描述 “误用字符串”的一个小节，从中了解到go中字符串拼接如果直接用 + 进行拼接的话，效率会比较低，当在for循环次数比较多的时候比较明显，然后我就测试了。那边书中上提供的是用另外一种方式，在f...
二. go 高性能编程之 字符串拼接问题
qq_29799655的博客
05-04 295
【代码】二. go 高性能编程之 字符串拼接问题。
Golang-字符串拼接的性能及原理
qq_23587709的博客
02-16 2130
1.字符串高效拼接 在go语言中，字符串（string）是不可变的，因此字符串之间的拼接实际上是创建了一个新的字符串。如果频繁的进行字符串拼接，那将会对性能产生严重的影响！ 1.1常见的拼接方式 （1）使用 + func plusConcat(n int, str string) string { s := "" for i := 0; i < n; i++ { s += str } return s } （2）使用fmt.Sprintf func sprintfConcat(n i
go字符串拼接方式及性能比拼
Peerless__的博客
09-25 2263
在golang中字符串的拼接方式有多种，本文将会介绍比较常用的几种方式，并且对各种方式进行压测，以此来得到在不同场景下更适合使用的方案。
Go语言字符串各种拼接的性能对比
xiaoyuanhaoyuan的博客
08-15 147
其中使用直接 + 是最慢的也是最耗费内存的，使用strings.Builder能大幅提升性能。综合来看直接使用strings.Join方法是非常不错的。
golang中拼接字符串性能问题
猛犸象
05-07 369
字符串在内存中是不可变的，修改后的字符串会重新放入新的地址，因此拼接字符串可能出现的性能问题就是频繁的内存分配，比如： func s1(ids []string) (s string) { for _, id := range ids { s += id } return } 在golang中，具有预先分配内存特性的是切片，如果预先就分配好内存，然后再依次将字符串装进去就避免了内存的频繁分配。 再来看看strings包的实现 func Join(elems []string, sep strin
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值