Java8⼏种常⽤字符串拼接⽅法总结
字符串的拼接在Java开发过程中经常被使⽤，Java中提供了6种常⽤的字符串拼接⽅法，本⽂主要介绍这⼏种拼接⽅法的使⽤1、使⽤"+"号
public static void main(String[] args){
String str1 ="Hello";
String str2 ="World";
long startTimes = w().toEpochMilli();
System.out.println("开始时间："+ startTimes);
for(int i =0; i <100000; i++){
String str = str1 +","+ str2;
}
long endTimes = w().toEpochMilli();
System.out.println("结束时间："+ endTimes);
System.out.println("使⽤+执⾏100000次字符串拼接耗时为："+(endTimes - startTimes)+"毫秒");
}
执⾏结果
开始时间：1610177104871
结束时间：1610177104916
使⽤+执⾏100000次字符串拼接耗时为：45毫秒
开始时间：1610177903188
结束时间：1610177903195
使⽤+执⾏10000次字符串拼接耗时为：7毫秒
2、使⽤concat
public static void main(String[] args){
String str1 ="Hello";
String str2 ="World";
long startTimes = w().toEpochMilli();
System.out.println("开始时间："+ startTimes);
for(int i =0; i <100000; i++){
String str = at(",").concat(str2);
}
long endTimes = w().toEpochMilli();
System.out.println("结束时间："+ endTimes);
System.out.println("使⽤concat执⾏100000次字符串拼接耗时为："+(endTimes - startTimes)+"毫秒");
java的tostring方法
}
执⾏结果
开始时间：1610177258860
结束时间：1610177258916
使⽤concat执⾏100000次字符串拼接耗时为：56毫秒
开始时间：1610177958826
结束时间：1610177958832
使⽤concat执⾏10000次字符串拼接耗时为：6毫秒
3、使⽤StringBuffer
StringBuffer stringBuffer =new StringBuffer();
long startTimes = w().toEpochMilli();
System.out.println("开始时间："+ startTimes);
for(int i =0; i <100000; i++){
stringBuffer.append(str1);
stringBuffer.append(",");
stringBuffer.append(str2);
}
long endTimes = w().toEpochMilli();
System.out.println("结束时间："+ endTimes);
System.out.println("使⽤StringBuffer执⾏100000次字符串拼接耗时为："+(endTimes - startTimes)+"毫秒"); }
执⾏结果
开始时间：1610177353095
结束时间：1610177353125
使⽤StringBuffer执⾏100000次字符串拼接耗时为：30毫秒
开始时间：1610178077641
结束时间：1610178077647
使⽤StringBuffer执⾏10000次字符串拼接耗时为：6毫秒
4、使⽤StringBuilder
public static void main(String[] args){
String str1 ="Hello";
String str2 ="World";
StringBuilder stringBuilder =new StringBuilder();
long startTimes = w().toEpochMilli();
System.out.println("开始时间："+ startTimes);
for(int i =0; i <100000; i++){
stringBuilder.append(str1);
stringBuilder.append(",");
stringBuilder.append(str2);
}
long endTimes = w().toEpochMilli();
System.out.println("结束时间："+ endTimes);
System.out.println("使⽤StringBuilder执⾏100000次字符串拼接耗时为："+(endTimes - startTimes)+"毫秒"); }
执⾏结果
开始时间：1610177416041
结束时间：1610177416071
使⽤StringBuilder执⾏100000次字符串拼接耗时为：30毫秒
开始时间：1610178027855
结束时间：1610178027860
使⽤StringBuilder执⾏10000次字符串拼接耗时为：5毫秒
5、使⽤String.join
long startTimes = w().toEpochMilli();
System.out.println("开始时间："+ startTimes);
for(int i =0; i <100000; i++){
String.join(",", str1, str2);
}
long endTimes = w().toEpochMilli();
System.out.println("结束时间："+ endTimes);
System.out.println("使⽤join执⾏100000次字符串拼接耗时为："+(endTimes - startTimes)+"毫秒");
}
执⾏结果
开始时间：1610177523763
结束时间：1610177523864
使⽤join执⾏100000次字符串拼接耗时为：101毫秒
开始时间：1610178127784
结束时间：1610178127842
使⽤join执⾏10000次字符串拼接耗时为：58毫秒
6、使⽤StringJoiner
public static void main(String[] args){
String str1 ="Hello";
String str2 ="World";
StringJoiner stringJoiner =new StringJoiner(",");
long startTimes = w().toEpochMilli();
System.out.println("开始时间："+ startTimes);
for(int i =0; i <100000; i++){
stringJoiner.add(str1);
stringJoiner.add(str2);
}
long endTimes = w().toEpochMilli();
System.out.println("结束时间："+ endTimes);
System.out.println("使⽤StringJoiner执⾏100000次字符串拼接耗时为："+(endTimes - startTimes)+"毫秒");
}
执⾏结果
开始时间：1610177674666
结束时间：1610177674711
使⽤StringJoiner执⾏100000次字符串拼接耗时为：45毫秒
开始时间：1610177846418
结束时间：1610177846426
使⽤StringJoiner执⾏10000次字符串拼接耗时为：8毫秒
总结：使⽤"+"连接字符串时，使⽤javap -c 反编译后，发现编译器⾃动引⼊了StringBuilder类，在⼤规模场景中，为连接n个字符串重复地使⽤字符串连接操作符，需要n的平⽅级的时间。这是由于字符串不可变⽽导致的结果，当字符串连接在⼀起时，内容都要被拷贝；String.join的底层调⽤了StringJoiner，源码如下：
public static String join(CharSequence delimiter, elements){
// Number of elements not likely worth Arrays.stream overhead.
StringJoiner joiner =new StringJoiner(delimiter);
for(CharSequence cs: elements){
joiner.add(cs);
}
String();
}
再进⼊StringJoiner源码，底层使⽤了StringBuilder，源码如下：
private StringBuilder value;
public StringJoiner add(CharSequence newElement){
prepareBuilder().append(newElement);
return this;
}
private StringBuilder prepareBuilder(){
if(value != null){
value.append(delimiter);
}else{
value =new StringBuilder().append(prefix);
}
return value;
}
所以在字符串拼接时，不考虑多线程情况下，建议直接使⽤StringBuilder，同继承于AbstractStringBuilder的StringBuffer使⽤了synchronized，保证了线程的安全，多线程情况下使⽤StringBuffer，源码如下：
public synchronized StringBuffer append(String str){
toStringCache = null;
super.append(str);
return this;
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。