转自：http://blog.csdn.net/u010168160/article/details/52021652
最近在项目中见到一个比较特别的代码，因为之前没见过，可能是孤陋寡闻了。我们平时用的最简单的字符串拼接就是用“+”号连接起来，要么我们就实例化一个StringBuilder或StringBuffer，然后拼接字符串。可是我见到的居然是用String.format将字符串拼起来的。那么我们就来看看到底是怎么回事吧。
一、String.Format
1、简介
String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。
2、参数
format()方法有两种重载形式。
format(String format, Object… args) 新字符串使用本地语言环境，制定字符串格式和参数生成格式化的新字符串。
format(Locale locale, String format, Object… args) 使用指定的语言环境，制定字符串格式和参数生成格式化的字符串。
3、用法
4、实例
//测试
public static void main(String[] args) {
String str=null;
str=String.format("Hi,%s", "王力");
System.out.println(str);
str=String.format("Hi,%s:%s.%s", "王南","王力","王张");
System.out.println(str);
System.out.printf("字母a的大写是：%c %n", 'A');
System.out.printf("3>7的结果是：%b %n", 3>7);
System.out.printf("100的一半是：%d %n", 100/2);
System.out.printf("100的16进制数是：%x %n", 100);
System.out.printf("100的8进制数是：%o %n", 100);
System.out.printf("50元的书打8.5折扣是：%f 元%n", 50*0.85);
System.out.printf("上面价格的16进制数是：%a %n", 50*0.85);
System.out.printf("上面价格的指数表示：%e %n", 50*0.85);
System.out.printf("上面价格的指数和浮点数结果的长度较短的是：%g %n", 50*0.85);
System.out.printf("上面的折扣是%d%% %n", 85);
System.out.printf("字母A的散列码是：%h %n", 'A');
}
//结果
Hi,王力
Hi,王南:王力.王张
字母a的大写是：A
3>7的结果是：false
100的一半是：50
100的16进制数是：64
100的8进制数是：144
50元的书打8.5折扣是：42.500000 元
上面价格的16进制数是：0x1.54p5
上面价格的指数表示：4.250000e+01
上面价格的指数和浮点数结果的长度较短的是：42.5000
上面的折扣是85%
字母A的散列码是：41 二、比较
1、实例说明
package com.jiedaibao.pay.account.accounting.p.general;
import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Unit test for simple App.
*/
public class AppTest extends TestCase {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
public void testPlus() {
String s = "";
long ts = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
s = s + String.valueOf(i);
}
long te = System.currentTimeMillis();
logger.info("+ cost {} ms", te - ts);
}
public void testConcat() {
String s = "";
long ts = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
s = s.concat(String.valueOf(i));
}
long te = System.currentTimeMillis();
logger.info("concat cost {} ms", te - ts);
}
public void testJoin() {
List<String> list = new ArrayList<String>();
long ts = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
list.add(String.valueOf(i));
}
StringUtils.join(list, "");
long te = System.currentTimeMillis();
logger.info("StringUtils.join cost {} ms", te - ts);
}
public void testStringBuffer() {
StringBuffer sb = new StringBuffer();
long ts = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
sb.append(String.valueOf(i));
}
sb.toString();
long te = System.currentTimeMillis();
logger.info("StringBuffer cost {} ms", te - ts);
}
public void testStringBuilder() {
StringBuilder sb = new StringBuilder();
long ts = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
sb.append(String.valueOf(i));
}
sb.toString();
long te = System.currentTimeMillis();
logger.info("StringBuilder cost {} ms", te - ts);
}
public void testStringFormat() {
String str="";
long ts = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
str=String.format("%s%s",str,String.valueOf(i));
}
str.toString();
long te = System.currentTimeMillis();
logger.info("StringBuilder cost {} ms", te - ts);
}
}耗时显示
特别注意：
StringBuilder 循环的次数是其它的10倍，如果是一样，那么返回 0，可见StringBuilder 的速度之快。
2、原理
为什么String.Format耗时这么厉害呢，我们来看看源码
- StringBuilder的源码
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; }
- String.format的源码
核心实体的初始化，可以看到创建了一个StringBuilder作为了Formatter的全局变量。
public Formatter() {
this(Locale.getDefault(Locale.Category.FORMAT), new StringBuilder());
}具体实现
public Formatter format(Locale l, String format, Object ... args) { ensureOpen(); // index of last argument referenced int last = -1; // last ordinary index int lasto = -1; FormatString[] fsa = parse(format); for (int i = 0; i < fsa.length; i++) { FormatString fs = fsa[i]; int index = fs.index(); try { switch (index) { case -2: // fixed string, "%n", or "%%" fs.print(null, l); break; case -1: // relative index if (last < 0 || (args != null && last > args.length - 1)) throw new MissingFormatArgumentException(fs.toString()); fs.print((args == null ? null : args[last]), l); break; case 0: // ordinary index lasto++; last = lasto; if (args != null && lasto > args.length - 1) throw new MissingFormatArgumentException(fs.toString()); fs.print((args == null ? null : args[lasto]), l); break; default: // explicit index last = index - 1; if (args != null && last > args.length - 1) throw new MissingFormatArgumentException(fs.toString()); fs.print((args == null ? null : args[last]), l); break; } } catch (IOException x) { lastException = x; } } return this; }这下我们就明白了，原来String.format也是通过StringBuilder来时实现的。通过上面分析我们可以得出这样的结论：StringBuilder是其他两种方式的基础实现，所以还是StringBuilder比较占优势。
总结：
用+的方式效率最差，concat由于是内部机制实现，比+的方式好了不少。Join 和 StringBuffer，相差不大，Join方式要快些，可见这种JavaScript中快速拼接字符串的方式在Java中也非常适用。StringBuilder 的速度最快，但其有线程安全的问题，而且只有JDK5支持。
