「译」在java中，字符串的加法是如何实现的？

 

原文：How is + implemented in Java?

译文：在java中，字符串的加法是如何实现的？

 

当我查看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);
}

那么，字符串的连接符（+）的实现和这个有什么区别呢？如果有区别的话，那它是如何实现的呢？

此外，这两者分别在什么场合使用，有没有性能上的差异。

 

为了回答这个问题，我们可以做一个测试。

首先，我们连接两个字符串

String s1 = "foo";
String s2 = "bar";
String s3 = s1 + s2;

下面我们将这个代码编译成class文件，然后再反编译（可以用JAD），我们得到反编译后的代码是：

String s = "foo";
String s1 = "bar";
String s2 = (new StringBuilder()).append(s).append(s1).toString();

所以，+ 和 concat 肯定是有区别的。

在性能上，从 concat() 源码可以看出，StringBuilder创建了更多的对象，而concat却没有，它使用的String类的内部实现。

 

综上，当我们需要连接两个字符串的时候，我们应当优先考虑使用 concat() 函数，当我们需要连接字符串和其它类型的变量时，再考虑使用+运算符。

 

译者注：用 javap -c 查看java生成的字节码：

java.lang.String cat(java.lang.String, java.lang.String);
  Code:
   0:   new     #2; //class java/lang/StringBuilder
   3:   dup
   4:   invokespecial   #3; //Method java/lang/StringBuilder."<init>":()V
   7:   aload_1
   8:   invokevirtual   #4; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   11:  aload_2
   12:  invokevirtual   #4; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   15:  invokevirtual   #5; //Method java/lang/StringBuilder.toString:()Ljava/lang/    String;
   18:  astore_1
   19:  aload_1
   20:  areturn

可以看出 a += b 其实等价于

a = new StringBuilder()
    .append(a)
    .append(b)
    .toString();

评论

14 楼 runfriends 2013-01-02  

kidneyball 写道

runfriends 写道

楼主你用的是谁家的编译器啊？
我用jdk6、jdk7、eclipse jdt的编译器编译后再反编译回来的都还是+。

不排除这是你用的反编译器干的。这种事情还是直接看bytecode靠谱。
确实是我的反编译器的问题

runfriends 写道

在用+连接字符串时，每遇到一个+都会创建一个StringBuilder对象，调用两次append和一次toString()

很久很久以前做过测试，每个字符串连加的表达式只会创建一个StringBuilder。所以只有当字符串连接被分散在不同的表达式里，或者表达式在循环或者递归里，StringBuilder和加号连接才会有显著差异。

我又测试了一下，你是对的，我错了。之前是我测试不严格。
之前我测试的时候是在循环里面连接字符串。

runfriends 写道

在这个过程中如果调用n次append，最少创建一个append，最多创建n+1次

啥叫“创建一个append”呀？

我按错了键，应该是最少创建一个char[]，最多创建n+1个

13 楼 kidneyball 2013-01-02  

runfriends 写道

楼主你用的是谁家的编译器啊？
我用jdk6、jdk7、eclipse jdt的编译器编译后再反编译回来的都还是+。

不排除这是你用的反编译器干的。这种事情还是直接看bytecode靠谱。

runfriends 写道

在用+连接字符串时，每遇到一个+都会创建一个StringBuilder对象，调用两次append和一次toString()

很久很久以前做过测试，每个字符串连加的表达式只会创建一个StringBuilder。所以只有当字符串连接被分散在不同的表达式里，或者表达式在循环或者递归里，StringBuilder和加号连接才会有显著差异。

runfriends 写道

在这个过程中如果调用n次append，最少创建一个append，最多创建n+1次

啥叫“创建一个append”呀？

12 楼 runfriends 2012-12-31  

so the original article is incorrect!!!!

11 楼 runfriends 2012-12-31  

所以前面我说的那一些对jdk7也适用

10 楼 runfriends 2012-12-31  

楼主你用的是谁家的编译器啊？
我用jdk6、jdk7、eclipse jdt的编译器编译后再反编译回来的都还是+。

9 楼 runfriends 2012-12-31  

为什么我用+的时候反编译结果跟楼主的不一样呢？

8 楼 runfriends 2012-12-31  

讲运行期效率，对java来说当然是编译后的。
以下内容都是基于jdk6的。jdk7的没有试过。
另外实际上编译器并没有把+编译成StringBuilder，反编译以后还是+。
因此，有理由相信把+作为StringBuilder处理是jvm的行为。

单步调试就会发现下述情况。
在用+连接字符串时，每遇到一个+都会创建一个StringBuilder对象，调用两次append和一次toString()。
在这个过程中，假设连接一个字符串一共用到n个+，就创建了n个StringBuilder对象，调用了2n次append和n次toString。其中这n个StringBuilder内维持的char[]尺寸是默认的16个字符，在一次+操作中如果第一个append的参数长度超过16个字符，jvm还要重新创建一个新的char[]对象，然后把append实参转化成字符串的字符串逐字符复制到这个char[]对象内。调用第二个append时会重复上述过程。最后调用toString。
所以整个字符串连接完毕，最少会创建n个char[]，最多3n个。

如果显式使用StringBuilder连接，StringBuilder对象的数量由程序员控制，所以一般连接一次字符串只创建一个StringBuilder对象，如果规划的好，甚至连接数个字符串都可以只用一个StringBuilder对象。最后创建一个String对象。在这个过程中如果调用n次append，最少创建一个append，最多创建n+1次。

如果使用concat，每次调用，都会创建一个char[]和一个String，调用n次就会创建n个char[]和n个String。

这个3n和n+1的来历解释如下。
n个+会连接n+1个片断。显式使用StringBuilder，调用n次append会连接n个片断。
每次调用一个+都会调用StringBuilder无参构造器，这时会创建一个16个字符的char[]，
+左边的片断是一次append，这时如果char[]长度不够，又会创建一个char[]，
+右边的片断也是一次append，这时如果char[]长度还不够，又会创建一个char[]。
一次+最多创建三个char[]，n次+最多创建3n个。
显示使用StringBuilder，创建StringBuilder对象时创建一个char[]，以后每次调用append如果char[]长度不够就创建一个新的。所以调用n次append，最多创建n+1个char[]。
因此在最坏的情况下，使用+，创建了3n个char[]，才构造一个想要的字符串，中间还会产生n个作为中间结果的字符串；而显式使用StringBuilder，构造相同的字符串最多只创建了n+1个char[]，而且没有作为中间结果的字符串。

StringBuilder内char[]尺寸扩容算法如下：
//jdk7
void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
    }

//jdk6
void expandCapacity(int minimumCapacity) {
int newCapacity = (value.length + 1) * 2;
        if (newCapacity < 0) {
            newCapacity = Integer.MAX_VALUE;
        } else if (minimumCapacity > newCapacity) {
    newCapacity = minimumCapacity;
}
        value = Arrays.copyOf(value, newCapacity);
    }

足见两个版本的实现有显著差异，jdk6的实现有一个逻辑上的错误，就是判断newCapacity<0，这个判断永远也不会为true。
jdk7的实现相对更合理，不过也有问题因为miniCapacity是在执行append的时候如果原char[]对象不足以容纳append后的结果时才会调用expandCapacity，而mimumCapacity就是expandCapacity的实参，这个时候字符串长度如果超过了int最大值就会抛出OutOfMemoryError，而在这种情况下，只能说字符串太过于长了，而不一定会超出cpu寻址范围，也就不一定会耗尽jvm堆；因此在这里抛出OOM个人认为并不合适。

7 楼 Shen.Yiyang 2012-12-31  

人家都说了，现在编译器把+都编译成StringBuilder了，你还纠结什么 + 。。。

6 楼 runfriends 2012-12-31  

原文和楼主还有各位楼上的其实说的都不对。
我实际测试过StringBuilder与+的性能对比相差1000多倍。
2010年测试的，现在硬件性能更强，但是肯定仍然有明显差异，所以多个变量连接字符串还是应该使用StringBuilder，因为它只创建了一个StringBuilder对象，而且StringBuilder对它维护的char[]还有类似ArrayList实现的预置空间。

StringBuilder在连接过程中会创建一个StringBuilder、若干char[]，创建多少次char[]对象由调用append的次数和每次传入append的参数尺寸决定。最后如果还调用了toString()还会创建一个String对象

String的concat会在每次调用时都会创建一个char[]对象和一个String对象。
每出现一次+都会创建一个StringBuilder对象和一个String对象，StringBuilder对象里面还会创建一个char[]对象。

综上，我们可以得出以下结论。
如果只是连接两个字符串片段还是cancat性能最高，StringBuilder和+性能一样。
如果连接三个以上的字符串版本StringBuilder性能最高，concat次之，+最差。

5 楼 java_user 2012-12-31  

其实现在硬件性能很强大，如果不是习惯根本没有必要这样咬文嚼字

4 楼 shichuang2393 2012-12-31  

路过....

3 楼 Shen.Yiyang 2012-12-31  

contact也会创建new String啊，如果你的+运算有很多个字符串，那么也只会创建一个StringBuilder去append，contact则不然

2 楼 cuisuqiang 2012-12-31  

你很细心，不过开发者不必纠结这个，顶你！

1 楼 justjavac 2012-12-31  

concat() 函数中有这么一句：return new String(buf, true);