面试官请不要再问我StringBuffer与StringBuilder的区别了，源码讲你你听

梦里梦外; 2023-06-07 03:24 9阅读 0赞

StringBuffer类的定义——重点`final`,说明很多性质和`String`类似不可变  
继承自`AbstractStringBuilder`

public final class StringBuffer
        extends AbstractStringBuilder
        implements java.io.Serializable, CharSequence
    {……

无参构造函数，潜台词**默认初始容量为16**

/**
         * Constructs a string buffer with no characters in it and an
         * initial capacity of 16 characters.
         */
        public StringBuffer() {
            super(16);
        }

指定大小的构造函数

/**
         * Constructs a string buffer with no characters in it and
         * the specified initial capacity.
         *
         * @param      capacity  the initial capacity.
         * @exception  NegativeArraySizeException  if the {@code capacity}
         *               argument is less than {@code 0}.
         */
        public StringBuffer(int capacity) {
            super(capacity);
        }

super(capacity)的实现，底层是char数组

/**
         * Creates an AbstractStringBuilder of the specified capacity.
         */
        AbstractStringBuilder(int capacity) {
            value = new char[capacity];
        }

指定字符串的构造函数，潜台词：**容量为串的长度+16**

/**
         * Constructs a string buffer initialized to the contents of the
         * specified string. The initial capacity of the string buffer is
         * {@code 16} plus the length of the string argument.
         *
         * @param   str   the initial contents of the buffer.
         */
        public StringBuffer(String str) {
            super(str.length() + 16);
            append(str);
        }

append方法

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

重点`synchronized`:线程安全的，实际实现还是要看父类  
  
父类的实现：

/**
 * Appends the specified string to this character sequence.
 * 
 * The characters of the {@code String} argument are appended, in
 * order, increasing the length of this sequence by the length of the
 * argument. If {@code str} is {@code null}, then the four
 * characters {@code "null"} are appended.
 * 
 * Let n be the length of this character sequence just prior to
 * execution of the {@code append} method. Then the character at
 * index k in the new character sequence is equal to the character
 * at index k in the old character sequence, if k is less
 * than n; otherwise, it is equal to the character at index
 * k-n in the argument {@code str}.
 *
 * @param str a string.
 * @return a reference to this object.
 */
 public AbstractStringBuilder append(String str) {
 if (str == null)
 return appendNull();
 int len = str.length();
 ensureCapacityInternal(count + len);
 str.getChars(0, len, value, count);// 从0开始，到当前数组长度，进行拷贝
 count += len;
 return this;
 }

分析`ensureCapacityInternal(count + len);`目的是为了确保容量至少等于指定的最小值

/**
       * For positive values of {@code minimumCapacity}, this method
       * behaves like {@code ensureCapacity}, however it is never
       * synchronized.
       * If {@code minimumCapacity} is non positive due to numeric
       * overflow, this method throws {@code OutOfMemoryError}.
       */
      private void ensureCapacityInternal(int minimumCapacity) {
          // overflow-conscious code
          if (minimumCapacity - value.length > 0) {
              value = Arrays.copyOf(value,
                      newCapacity(minimumCapacity));
          }
      }

再看StringBuilder，几乎一样，不同处是append方法，没有采取同步措施

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

总结：StringBuilder/StringBuffer均继承自AbstractStringBuilder，大多底层方法均由AbstractStringBuilder实现，默认容量均为16  
不同之处在于：**StringBuffer线程安全，而StringBuilder线程不安全**