String.format参加字符串拼接大比拼
最近在项目中见到一个比较特别的代码，因为之前没见过，可能是孤陋寡闻了。我们平时用的最简单的字符串拼接就是用“+”号连接起来，要么我们就实例化一个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;
}
其中value是一个char[]类型，我们可以大概了解到实现字符串拼接的原理是字符数组的拷贝操作实现的。其实两个字符串相加的本质也是StringBuilder的方式相加的，但是会创建多余的字符串对象。
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支持。
原文地址：https://blog.csdn.net/u010168160/article/details/52021652