一、字符串连接的效率问题
使用String连接字符串时为什么慢？
小知识点
java中对数组进行初始化后，该数组所占的内存空间、数组长度都是不可变的。
创建一个字符串，为字符串对象分配内存空间，会耗费掉一定的时间(CPU)与空间(内存)代价，作为最基础的数据类型，大量频繁的创建字符串，极大程度地影响程序的性能。
过多无用的中间对象
每次连接字符串时都会创建一个新的String对象，随着拼接次数的增多，这个对象会越来越大。 如，进行100次拼接需要创建100个String对象才能够达到目的。
StringBuilder在连接时为什么效率更高？
字符数组的扩容机制:
private void ensureCapacityInternal(int minimumCapacity) { // 最小所需容量minimumCapacity是否比原数组长度要长 // overflow-conscious code if (minimumCapacity - value.length > 0) { value = Arrays.copyOf(value, newCapacity(minimumCapacity)); } } private int newCapacity(int minCapacity) { // 计算扩容之后的容量newCapacity // overflow-conscious code int newCapacity = (value.length << 1) + 2; // 扩容后还小于所需的最小容量 if (newCapacity - minCapacity < 0) { // 设置新容量为最小所需容量minimumCapacity newCapacity = minCapacity; } // newCapacity是否溢出，newCapacity是否比数组所能分配的最大容量 MAX_ARRAY_SIZE 还要大。 return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0) ? hugeCapacity(minCapacity) : newCapacity; } private int hugeCapacity(int minCapacity) { // 最小所需容量minCapacity大于Integer.MAX_VALUE时抛出内存溢出异常 if (Integer.MAX_VALUE - minCapacity < 0) { // overflow throw new OutOfMemoryError(); } // 如果minCapacity介于MAX_ARRAY_SIZE和Integer.MAX_VALUE之间，则新的容量为minCapacity，否则直接使用MAX_ARRAY_SIZE作为新的容量。 return (minCapacity > MAX_ARRAY_SIZE) ? minCapacity : MAX_ARRAY_SIZE; }
向原StringBuilder对象中追加字符串时：
1.追加对象str为null时追加'null'字符
2.确认是否需要进行扩容操作
- 最小所需容量minimumCapacity是否比原数组长度要长，即当原数组长度不能满足所需最小容量时进行扩容操作。
- 计算扩容之后的容量newCapacity，newCapacity = (value.length * 2) + 2。
- 扩容后是否还小于所需的最小容量，如果小于则直接设置新容量为最小所需容量minimumCapacity。
- newCapacity是否溢出，newCapacity是否比数组所能分配的最大容量 MAX_ARRAY_SIZE 还要大。如果是的话则判断，最小所需容量minCapacity大于Integer.MAX_VALUE时抛出内存溢出异常，如果minCapacity介于MAX_ARRAY_SIZE和Integer.MAX_VALUE之间，则新的容量为minCapacity，否则直接使用MAX_ARRAY_SIZE作为新的容量。
3.str.getChars()将str追加到value的末尾
效率高的原因
- 扩容机制保证了，只有在满足扩容条件
minimumCapacity - value.length > 0时才会进行扩容生成新的数组，所以大部分情况都是在对原数组进行操作，避免了产生过多的无用char[]对象，节省了系统资源的开销。
代码
/** * 比较字符串连接速度 * * @Author: lingyejun * @Date: 2019/8/17 * @Describe: * @Modified By: */ public class LinkCompare { /** * 原始字符串连接 * * @param times */ public static void linkByString(int times) { Long startTime = System.currentTimeMillis(); String initStr = ""; for (int i = 0; i < times; i++) { initStr = initStr + i; } Long endTime = System.currentTimeMillis(); System.out.println("String 连接 " + times + " 次 消耗:" + (endTime - startTime) + "ms"); } /** * 使用StringBuilder连接字符串 * * @param times */ public static void linkByStringBuilder(int times) { Long startTime = System.currentTimeMillis(); StringBuilder initStr = new StringBuilder(); for (int i = 0; i < times; i++) { initStr.append(i); } Long endTime = System.currentTimeMillis(); System.out.println("StringBuilder 连接 " + times + " 次 消耗:" + (endTime - startTime) + "ms"); } /** * 使用StringBuffer连接字符串 * * @param times */ public static void linkByStringBuffer(int times) { Long startTime = System.currentTimeMillis(); StringBuffer initStr = new StringBuffer(); for (int i = 0; i < times; i++) { initStr.append(i); } Long endTime = System.currentTimeMillis(); System.out.println("StringBuffer 连接 " + times + " 次 消耗:" + (endTime - startTime) + "ms"); } public static void main(String[] args) { // 100000000 linkByStringBuilder(40000); //-XX:+PrintGCDetails //linkByString(40000); } }
二、StringBuilder和String Buffer的线程安全比较
验证StringBuffer的线程安全性
线程不安全的原因
public StringBuilder append(String str) { super.append(str); return this; } public synchronized StringBuffer append(String str) { toStringCache = null; super.append(str); return this; }
测试代码
import java.util.ArrayList; import java.util.List; /** * StringBuilder和StringBuffer的并发测验 * * @Author: lingyejun * @Date: 2019/8/17 * @Describe: * @Modified By: */ public class SecurityCompare { public void stringBuilderTest() { // 初始化StringBuilder StringBuilder stringBuilder = new StringBuilder(); // joinList List<StringBuilderThread> joinList = new ArrayList<>(); // 模拟并发场景 for (int i = 0; i < 1000; i++) { StringBuilderThread sbt = new StringBuilderThread(stringBuilder); sbt.start(); joinList.add(sbt); } // 等待append线程执行完毕后再执行主线程 for (StringBuilderThread thread : joinList) { try { thread.join(); } catch (InterruptedException e) { e.printStackTrace(); } } // 打印最终的结果 System.out.println("StringBuilder 并发append的结果： " + stringBuilder.length()); } public void stringBufferTest() { // 初始化StringBuffer StringBuffer stringBuffer = new StringBuffer(); // joinList List<StringBufferThread> joinList = new ArrayList<>(); // 模拟并发场景 for (int i = 0; i < 1000; i++) { StringBufferThread sbf = new StringBufferThread(stringBuffer); sbf.start(); joinList.add(sbf); } // 等待append线程执行完毕后再执行主线程 for (StringBufferThread thread : joinList) { try { thread.join(); } catch (InterruptedException e) { e.printStackTrace(); } } // 打印最终的结果 System.out.println("StringBuffer 并发append的结果： " + stringBuffer.length()); } public static void main(String[] args) { SecurityCompare securityCompare = new SecurityCompare(); securityCompare.stringBuilderTest(); securityCompare.stringBufferTest(); } public static class StringBuilderThread extends Thread { private StringBuilder stringBuilder; public StringBuilderThread(StringBuilder stringBuilder) { this.stringBuilder = stringBuilder; } @Override public void run() { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } stringBuilder.append("a"); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } } } private static class StringBufferThread extends Thread { private StringBuffer stringBuffer; public StringBufferThread(StringBuffer stringBuffer) { this.stringBuffer = stringBuffer; } @Override public void run() { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } stringBuffer.append("a"); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } } } }
三、结论
- String为固定长度的字符串，StringBuilder和StringBuffer为变长字符串。
- StringBuffer是线程安全的，StringBuilder是非线程安全的。
- StringBuilder和StringBuffer的默认初始容量是16，可以提前预估好字符串的长度，进一步减少扩容带来的额外开销。
