StringBuffer与StringBuilder拼接字符串时的区别

淡淡的烟草味﹌ 2021-09-24 00:08 460阅读 0赞

jdk版本为1.8

StringBuffer与StringBuilder继承自同一父类AbstractStringBuilder，append的源码分别为  
**StringBuffer**

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

**StringBuilder**

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

其中toStringCache 为用在toString方法中的缓存变量，与字符串拼接无关，所以，这两个类在拼接字符串时的唯一区别就只有同步。

### 同步上的区别具体体现在哪 ###

运行下面这段代码（具体循环次数需要根据电脑配置来定，否则有可能无法输出预期结果）

import java.util.concurrent.CountDownLatch;
    
    public class Test02 { 
    	
    	static StringBuilder str = new StringBuilder();
    	
    	static String append1 = "1111111111";
    	static String append2 = "aaaaaaaaaa";
    	
    	public static void main(String[] args) throws InterruptedException { 
    		CountDownLatch cl = new CountDownLatch(2);
    		new Thread(() -> { 
    			for(int i = 0; i < 1000; i++) { 
    				str.append(append1 + "\r\n");
    			}
    			cl.countDown();
    			System.out.println(str);
    		}).start();
    		new Thread(() -> { 
    			for(int i = 0; i < 1000; i++) { 
    				str.append(append2 + "\r\n");
    			}
    			cl.countDown();
    			System.out.println(str);
    		}).start();
    		
    		cl.await();
    		
    	}
    	
    }

会在控制台看到类似这样的输出  
![在这里插入图片描述][2020030412210935.png]  
这就是非同步代码在多线程下产生的错误，而在线程安全的StringBuffer中则不会出现这种问题。

具体到源码上来分析的话，这两个类在底层调用的都是  
`System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);`  
原因就是在复制时出现了不同步的问题。

### StringBuffer，StringBuilder与String在拼接字符串时效率的差异 ###

既然都看源码了，就顺便说一下

首先是String的加号（+），这个是毫无争议的最慢，具体原因需要反编译来分析，有时间再搞。这里主要比较String的concat与AbstractStringBuilder的append

运行下面代码

public class Test01 { 
    
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub
    		String s1 = "";
    		s1.concat("1");
    		StringBuffer s2 = new StringBuffer("");
    		s2.append("1");
    		StringBuilder s3 = new StringBuilder("");
    		s3.append("1");
    		
    		long time = System.currentTimeMillis();
    		for(int i = 0; i < 200000; i++) { 
    			s1 = s1.concat("1");
    		}
    		System.out.println(System.currentTimeMillis() - time);
    		time = System.currentTimeMillis();
    		s1 = "";
    		
    		for(int i = 0; i < 200000; i++) { 
    			s2.append("1");
    		}
    		
    		System.out.println(System.currentTimeMillis() - time);
    		time = System.currentTimeMillis();
    		
    		for(int i = 0; i < 200000; i++) { 
    			s3.append("1");
    		}
    		
    		System.out.println(System.currentTimeMillis() - time);
    		time = System.currentTimeMillis();
    	}
    
    }

输出

6602
    6
    2

可以看出StringBuilder由于没有同步，所以略微快于StringBuffer，但是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);
        }

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

可以看到，concat是每进行一次拼接，都会字符串数组进行一次复制，而append方法则有一个类似缓存的机制。ensureCapacityInternal方法会在数组长度不足时进行倍增复制，当长度足够时，append方法只是将新加入的字符串直接复制到数组的末尾。总的来说，就是concat方法进行数组复制的次数要远大于append，自然速度就慢了。

[2020030412210935.png]: /images/20210923/683a3c34b2c34c218cb770c337b399d0.png