为何不建议在for循环中使用"+"进行字符串拼接

时间  2019-11-09
标签 为何 建议 循环 使用 进行 字符串 拼接 繁體版
原文   原文链接

摘要： 学习阿里巴巴Java开发手册。java

Fundebug经受权转载，版权归原做者全部。程序员

字符串，是Java中最经常使用的一个数据类型了。关于字符串的知识，做者已经发表过几篇文章介绍过不少，如：apache

本文，也是对于Java中字符串相关知识的一个补充，主要来介绍一下字符串拼接相关的知识。本文基于jdk1.8.0_181。数组

字符串拼接

字符串拼接是咱们在Java代码中比较常常要作的事情，就是把多个字符串拼接到一块儿。缓存

咱们都知道，String是Java中一个不可变的类，因此他一旦被实例化就没法被修改。安全

不可变类的实例一旦建立，其成员变量的值就不能被修改。这样设计有不少好处，好比能够缓存hashcode、使用更加便利以及更加安全等。

可是，既然字符串是不可变的，那么字符串拼接又是怎么回事呢？微信

字符串不变性与字符串拼接并发

其实，全部的所谓字符串拼接，都是从新生成了一个新的字符串。下面一段字符串拼接代码：app

String s = "abcd";
s = s.concat("ef");

其实最后咱们获得的s已是一个新的字符串了。以下图函数

s中保存的是一个从新建立出来的String对象的引用。

那么，在Java中，到底如何进行字符串拼接呢？字符串拼接有不少种方式，这里简单介绍几种比较经常使用的。

使用+拼接字符串

在Java中，拼接字符串最简单的方式就是直接使用符号+来拼接。如：

String wechat = "Hollis";
String introduce = "每日更新Java相关技术文章";
String hollis = wechat + "," + introduce;

这里要特别说明一点，有人把Java中使用+拼接字符串的功能理解为运算符重载。其实并非，Java是不支持运算符重载的。这其实只是Java提供的一个语法糖。后面再详细介绍。

运算符重载：在计算机程序设计中，运算符重载（英语：operator overloading）是多态的一种。运算符重载，就是对已有的运算符从新进行定义，赋予其另外一种功能，以适应不一样的数据类型。

语法糖：语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，可是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。

concat
除了使用+拼接字符串以外，还可使用String类中的方法concat方法来拼接字符串。如：

String wechat = "Hollis";
String introduce = "每日更新Java相关技术文章";
String hollis = wechat.concat(",").concat(introduce);

StringBuffer

关于字符串，Java中除了定义了一个能够用来定义字符串常量的String类之外，还提供了能够用来定义字符串变量的StringBuffer类，它的对象是能够扩充和修改的。

使用StringBuffer能够方便的对字符串进行拼接。如：

StringBuffer wechat = new StringBuffer("Hollis");
String introduce = "每日更新Java相关技术文章";
StringBuffer hollis = wechat.append(",").append(introduce);

StringBuilder
除了StringBuffer之外，还有一个类StringBuilder也可使用，其用法和StringBuffer相似。如：

StringBuilder wechat = new StringBuilder("Hollis");
String introduce = "每日更新Java相关技术文章";
StringBuilder hollis = wechat.append(",").append(introduce);

StringUtils.join
除了JDK中内置的字符串拼接方法，还可使用一些开源类库中提供的字符串拼接方法名，如apache.commons中提供的StringUtils类，其中的join方法能够拼接字符串。

String wechat = "Hollis";
String introduce = "每日更新Java相关技术文章";
System.out.println(StringUtils.join(wechat, ",", introduce));

这里简单说一下，StringUtils中提供的join方法，最主要的功能是：将数组或集合以某拼接符拼接到一块儿造成新的字符串，如：

String []list  ={"Hollis","每日更新Java相关技术文章"};
String result= StringUtils.join(list,",");
System.out.println(result);
//结果：Hollis,每日更新Java相关技术文章

而且，Java8中的String类中也提供了一个静态的join方法，用法和StringUtils.join相似。

以上就是比较经常使用的五种在Java种拼接字符串的方式，那么到底哪一种更好用呢？为何阿里巴巴Java开发手册中不建议在循环体中使用+进行字符串拼接呢？

使用+拼接字符串的实现原理

前面提到过，使用+拼接字符串，其实只是Java提供的一个语法糖， 那么，咱们就来解一解这个语法糖，看看他的内部原理究竟是如何实现的。

仍是这样一段代码。咱们把他生成的字节码进行反编译，看看结果。

String wechat = "Hollis";
String introduce = "每日更新Java相关技术文章";
String hollis = wechat + "," + introduce;

反编译后的内容以下，反编译工具为jad。

String wechat = "Hollis";
String introduce = "\u6BCF\u65E5\u66F4\u65B0Java\u76F8\u5173\u6280\u672F\u6587\u7AE0";//每日更新Java相关技术文章
String hollis = (new StringBuilder()).append(wechat).append(",").append(introduce).toString();

经过查看反编译之后的代码，咱们能够发现，原来字符串常量在拼接过程当中，是将String转成了StringBuilder后，使用其append方法进行处理的。

那么也就是说，Java中的+对字符串的拼接，其实现原理是使用StringBuilder.append。

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

这段代码首先建立了一个字符数组，长度是已有字符串和待拼接字符串的长度之和，再把两个字符串的值复制到新的字符数组中，并使用这个字符数组建立一个新的String对象并返回。

经过源码咱们也能够看到，通过concat方法，实际上是new了一个新的String，这也就呼应到前面咱们说的字符串的不变性问题上了。

StringBuffer和StringBuilder

接下来咱们看看StringBuffer和StringBuilder的实现原理。

和String类相似，StringBuilder类也封装了一个字符数组，定义以下：

char[] value;

与String不一样的是，它并非final的，因此他是能够修改的。另外，与String不一样，字符数组中不必定全部位置都已经被使用，它有一个实例变量，表示数组中已经使用的字符个数，定义以下：

int count;

其append源码以下：

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

该类继承了AbstractStringBuilder类，看下其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;
}

append会直接拷贝字符到内部的字符数组中，若是字符数组长度不够，会进行扩展。

StringBuffer和StringBuilder相似，最大的区别就是StringBuffer是线程安全的，看一下StringBuffer的append方法。

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

该方法使用synchronized进行声明，说明是一个线程安全的方法。而StringBuilder则不是线程安全的。

StringUtils.join是如何实现的

经过查看StringUtils.join的源代码，咱们能够发现，其实他也是经过StringBuilder来实现的。

public static String join(final Object[] array, String separator, final int startIndex, final int endIndex) {
    if (array == null) {
        return null;
    }
    if (separator == null) {
        separator = EMPTY;
    }

    // endIndex - startIndex > 0:   Len = NofStrings *(len(firstString) + len(separator))
    //           (Assuming that all Strings are roughly equally long)
    final int noOfItems = endIndex - startIndex;
    if (noOfItems <= 0) {
        return EMPTY;
    }

    final StringBuilder buf = new StringBuilder(noOfItems * 16);

    for (int i = startIndex; i < endIndex; i++) {
        if (i > startIndex) {
            buf.append(separator);
        }
        if (array[i] != null) {
            buf.append(array[i]);
        }
    }
    return buf.toString();
}

效率比较

既然有这么多种字符串拼接的方法，那么到底哪种效率最高呢？咱们来简单对比一下。

long t1 = System.currentTimeMillis();
//这里是初始字符串定义
for (int i = 0; i < 50000; i++) {
    //这里是字符串拼接代码
}
long t2 = System.currentTimeMillis();
System.out.println("cost:" + (t2 - t1));

咱们使用形如以上形式的代码，分别测试下五种字符串拼接代码的运行时间。获得结果以下：

+ cost:5119
StringBuilder cost:3
StringBuffer cost:4
concat cost:3623
StringUtils.join cost:25726

从结果能够看出，用时从短到长的对比是：

StringBuilder`<`StringBuffer`<`concat`<`+`<`StringUtils.join

StringBuffer在StringBuilder的基础上，作了同步处理，因此在耗时上会相对多一些。

StringUtils.join也是使用了StringBuilder，而且其中仍是有不少其余操做，因此耗时较长，这个也容易理解。其实StringUtils.join更擅长处理字符串数组或者列表的拼接。

那么问题来了，前面咱们分析过，其实使用+拼接字符串的实现原理也是使用的StringBuilder，那为何结果相差这么多，高达1000多倍呢？

咱们再把如下代码反编译下：

long t1 = System.currentTimeMillis();
String str = "hollis";
for (int i = 0; i < 50000; i++) {
    String s = String.valueOf(i);
    str += s;
}
long t2 = System.currentTimeMillis();
System.out.println("+ cost:" + (t2 - t1));

反编译后代码以下：

long t1 = System.currentTimeMillis();
String str = "hollis";
for(int i = 0; i < 50000; i++)
{
    String s = String.valueOf(i);
    str = (new StringBuilder()).append(str).append(s).toString();
}

long t2 = System.currentTimeMillis();
System.out.println((new StringBuilder()).append("+ cost:").append(t2 - t1).toString());

咱们能够看到，反编译后的代码，在for循环中，每次都是new了一个StringBuilder，而后再把String转成StringBuilder，再进行append。

而频繁的新建对象固然要耗费不少时间了，不只仅会耗费时间，频繁的建立对象，还会形成内存资源的浪费。

因此，阿里巴巴Java开发手册建议：循环体内，字符串的链接方式，使用 StringBuilder 的 append 方法进行扩展。而不要使用+。

总结

本文介绍了什么是字符串拼接，虽然字符串是不可变的，可是仍是能够经过新建字符串的方式来进行字符串的拼接。

经常使用的字符串拼接方式有五种，分别是使用+、使用concat、使用StringBuilder、使用StringBuffer以及使用StringUtils.join。

因为字符串拼接过程当中会建立新的对象，因此若是要在一个循环体中进行字符串拼接，就要考虑内存问题和效率问题。

所以，通过对比，咱们发现，直接使用StringBuilder的方式是效率最高的。由于StringBuilder天生就是设计来定义可变字符串和字符串的变化操做的。

可是，还要强调的是：

  • 若是不是在循环体中进行字符串拼接的话，直接使用+就行了。
  • 若是在并发场景中进行字符串拼接的话，要使用StringBuffer来代替StringBuilder。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程