JAVA中StringBuffer和StringBuilder的區別是什么

這篇文章主要講解了“JAVA中StringBuffer和StringBuilder的區別是什么”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“JAVA中StringBuffer和StringBuilder的區別是什么”吧！

繼承關系

從源碼上看看類StringBuffer和StringBuilder的繼承結構：

從結構圖上可以直到，StringBuffer和StringBuiler都繼承自AbstractStringBuilder類

如何實現擴容

StringBuffer和StringBuiler的擴容的機制在抽象類AbstractStringBuilder中實現，當發現長度不夠的時候(默認長度是16)，會自動進行擴容工作，擴展為原數組長度的2倍加2，創建一個新的數組，并將數組的數據復制到新數組。

public void ensureCapacity(int minimumCapacity) { if (minimumCapacity > 0)  ensureCapacityInternal(minimumCapacity);} /*** 確保value字符數組不會越界.重新new一個數組,引用指向value*/ private void ensureCapacityInternal(int minimumCapacity) { // overflow-conscious code if (minimumCapacity - value.length > 0) {  value = Arrays.copyOf(value,    newCapacity(minimumCapacity)); }} /*** 擴容:將長度擴展到之前大小的2倍+2*/ private int newCapacity(int minCapacity) { // overflow-conscious code 擴大2倍+2 //這里可能會溢出,溢出后是負數哈,注意 int newCapacity = (value.length << 1) + 2; if (newCapacity - minCapacity < 0) {  newCapacity = minCapacity; } //MAX_ARRAY_SIZE的值是Integer.MAX_VALUE - 8,先判斷一下預期容量(newCapacity)是否在0<x<MAX_ARRAY_SIZE之間,在這區間內就直接將數值返回,不在這區間就去判斷一下是否溢出 return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)  ? hugeCapacity(minCapacity)  : newCapacity;} /*** 判斷大小，是否溢出*/private int hugeCapacity(int minCapacity) { if (Integer.MAX_VALUE - minCapacity < 0) { // overflow  throw new OutOfMemoryError(); } return (minCapacity > MAX_ARRAY_SIZE)  ? minCapacity : MAX_ARRAY_SIZE;}

線程安全性

我們先來看看StringBuffer的相關方法：

@Overridepublic synchronized StringBuffer append(long lng) { toStringCache = null; super.append(lng); return this;} /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @since  1.2 */@Overridepublic synchronized StringBuffer replace(int start, int end, String str) { toStringCache = null; super.replace(start, end, str); return this;} /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @since  1.2 */@Overridepublic synchronized String substring(int start) { return substring(start, count);} @Overridepublic synchronized String toString() { if (toStringCache == null) {  toStringCache = Arrays.copyOfRange(value, 0, count); } return new String(toStringCache, true);}

從上面的源碼中我們看到幾乎都是所有方法都加了synchronized,幾乎都是調用的父類的方法.，用synchronized關鍵字修飾意味著什么？加鎖，資源同步串行化處理，所以是線程安全的。

我們再來看看StringBuilder的相關源碼：

@Overridepublic StringBuilder append(double d) { super.append(d); return this;} /** * @since 1.5 */@Overridepublic StringBuilder appendCodePoint(int codePoint) { super.appendCodePoint(codePoint); return this;} /** * @throws StringIndexOutOfBoundsException {@inheritDoc} */@Overridepublic StringBuilder delete(int start, int end) { super.delete(start, end); return this;}

StringBuilder的源碼里面，基本上所有方法都沒有用synchronized關鍵字修飾，當多線程訪問時，就會出現線程安全性問題。

為了證明StringBuffer線程安全，StringBuilder線程不安全，我們通過一段代碼進行驗證：

測試思想

分別用1000個線程寫StringBuffer和StringBuilder，  使用CountDownLatch保證在各自1000個線程執行完之后才打印StringBuffer和StringBuilder長度，  觀察結果。

測試代碼

import java.util.concurrent.CountDownLatch; public class TestStringBuilderAndStringBuffer { public static void main(String[] args) {  //證明StringBuffer線程安全，StringBuilder線程不安全  StringBuffer stringBuffer = new StringBuffer();  StringBuilder stringBuilder = new StringBuilder();  CountDownLatch latch2 = new CountDownLatch(1000);  CountDownLatch latch3 = new CountDownLatch(1000);  for (int i = 0; i < 1000; i++) {   new Thread(new Runnable() {    @Override    public void run() {     try {      stringBuilder.append(1);     } catch (Exception e) {      e.printStackTrace();     } finally {      latch2.countDown();     }    }   }).start();  }  for (int i = 0; i < 1000; i++) {   new Thread(new Runnable() {    @Override    public void run() {     try {      stringBuffer.append(1);     } catch (Exception e) {      e.printStackTrace();     } finally {      latch3.countDown();     }     }   }).start();  }  try {   latch2.await();   System.out.println(stringBuilder.length());   latch3.await();   System.out.println(stringBuffer.length());  } catch (InterruptedException e) {   e.printStackTrace();  } }}

測試結果

StringBuffer不論運行多少次都是1000長度。  StringBuilder絕大多數情況長度都會小于1000。  StringBuffer線程安全，StringBuilder線程不安全得到證明。

總結一下

StringBuffer和StringBuilder都繼承自抽象類AbstractStringBuilder。  存儲數據的字符數組也沒有被final修飾，說明值可以改變，且構造出來的字符串還有空余位置拼接字符串，但是拼接下去肯定也有不夠用的時候，這時候它們內部都提供了一個自動擴容機制，當發現長度不夠的時候(默認長度是16)，會自動進行擴容工作，擴展為原數組長度的2倍加2，創建一個新的數組，并將數組的數據復制到新數組，所以對于拼接字符串效率要比String要高。自動擴容機制是在抽象類中實現的。  線程安全性：StringBuffer效率低，線程安全，因為StringBuffer中很多方法都被 synchronized 修飾了，多線程訪問時，線程安全，但是效率低下，因為它有加鎖和釋放鎖的過程。StringBuilder效率高，但是線程是不安全的。

感謝各位的閱讀，以上就是“JAVA中StringBuffer和StringBuilder的區別是什么”的內容了，經過本文的學習后，相信大家對JAVA中StringBuffer和StringBuilder的區別是什么這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！