JDk1.8源码StringBuffer

一、概念

StringBuffer 
A thread-safe, mutable sequence of characters. A string buffer is like a {@link String}, but can be modified.

源码开头的一句话：线程安全的，可变字符顺序。一个类似String的字符串缓冲区，但是可以修改的！

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

     /**
      * A cache of the last value returned by toString. Cleared
      * whenever the StringBuffer is modified.
      */
     private transient char[] toStringCache;

     /** use serialVersionUID from JDK 1.0.2 for interoperability */
     static final long serialVersionUID = 3388685877147921107L;

     ..........
 }

二、String定义成final

StringBuffer类跟String类一样定义成final形式，主要是为了“效率”和“安全性”的考虑，若StringBuffer 被继承，由于它的高使用率，可能会降低它的性能。

它继承了AbstractStringBuilder类，

 abstract class AbstractStringBuilder implements Appendable, CharSequence {
     /**
      * The value is used for character storage.与String类一样，定义了一个char类型的数组存储值
      */
     char value[];

     /**
      * The count is the number of characters used.
      */
     int count;

     /**
      * This no-arg constructor is necessary for serialization of subclasses.
      */
     AbstractStringBuilder() {
     }

而我们经常用到的是append方法，最常用的是 AbstractStringBuilder append(String str)

  public AbstractStringBuilder append(String str) {
         if (str == null)
             return appendNull();//如果str==null，就会将null添加到尾部
         int len = str.length();
         ensureCapacityInternal(count + len);//比较重要的的一步
         str.getChars(0, len, value, count);
         count += len;
         return this;
     }

ensureCapacityInternal(int minimumCapacity)，
确保容量至少等于指定的最小值。如果当前容量小于指定值，则创建新数组，新数组的容量为指定值的两倍加2；如果当前容量不小于指定值，则直接不做处理。

  /**
      * This method has the same contract as ensureCapacity, but is
      * never synchronized.
      */
     private void ensureCapacityInternal(int minimumCapacity) {
         // overflow-conscious code
         if (minimumCapacity - value.length > 0)
             expandCapacity(minimumCapacity);
     }

expandCapacity(int minimumCapacity)，

 void expandCapacity(int minimumCapacity) {
         int newCapacity = value.length * 2 + 2; //

• 定义一个是原容量的2倍+2大小的值

   

         if (newCapacity - minimumCapacity < 0)
             newCapacity = minimumCapacity;
         if (newCapacity < 0) {
             if (minimumCapacity < 0) // overflow

                 throw new OutOfMemoryError();
             newCapacity = Integer.MAX_VALUE;
         }
         value = Arrays.copyOf(value, newCapacity); //扩容
     }

  public static void main(String[] args) {
         StringBuffer sb = new StringBuffer();

         System.out.println("容量"+sb.capacity());
         sb.ensureCapacity(10);
         System.out.println("容量"+sb.capacity());

         sb.ensureCapacity(30);
         System.out.println("容量"+sb.capacity());//（16+1）*2=34>30
         sb.ensureCapacity(80);
         System.out.println("容量"+sb.capacity());//80>(34+1)*2=68
         sb.ensureCapacity(90);
         System.out.println("容量"+sb.capacity());//(80+1)*2>90

         //字符串返转
         sb.append("abcde");
         System.out.println(sb);
         sb.reverse();

         System.out.println(sb);

     }

结果：扩容的大小与（之前的长度+1）*2相比较，那个大用哪个

 容量16
 容量16
 容量34
 容量80
 容量162
 abcde
 edcba

----------------------------------------------------若有不正之处，欢迎大家指正，不胜感激！！！！！