StringBuilder的扩容机制

首先我们在使用String来操作字符串时，要知道存储String字符的底层容器是char[ ]，查看源码：

  /** The value is used for character storage. */
     private final char value[];

是char类型的数组，而且这个数组是被final修饰的，它是长度是无法修改的，那么String既然是用char数组来存储每个字符，那么它也是有限制的，通常我们是通过value.length()方法来获取字符串的长度，那么这个长度可不是无限制的，查看源码：

  /**
      * Returns the length of this string.
      * The length is equal to the number of <a href="Character.html#unicode">Unicode
      * code units</a> in the string.
      */
     public int length() {
         return value.length;
     }

这个length方法的返回值是int类型的，所以这个数组的长度取决于int类型以及其包装类Integer的取值范围，查看源码：

  /**
      * A constant holding the maximum value an {@code int} can
      * have, 2<sup>31</sup>-1.
      */
     @Native public static final int   MAX_VALUE = 0x7fffffff;

也就是说一旦超过这个范围同样虚拟机会提示，字符串长度过长。这是其一。比如我们使用String的concat方法去拼接1-1000的字符串形式：

 public static void main(String[] args) {
     String a = "1";
     for (int i = 2; i <= 1000; i++) {
       // 将a和*进行拼接
       a = a.concat("*");
       a = a + i;
     }
     System.out.println(a);
   }

这时会生成大量String类型的具体的变量.当生成的这些变量（临时数据）没有其他指向时，GC就会回收。这个过程中产生了大量的临时数据，占用很大的内存。第二这样垃圾回收器会去回收这些没用的数据，会严重影响到GC的效率。为了能够提高字符串的拼接的能力，那如何解决减小GC高频回收带来的消耗？就会使用到StringBuilder这个类：

 public class StringBuilderDemo {
 public static void main(String[] args) {
   StringBuilder sb=new StringBuilder(10);
   String ss="Today is Wednesday";
   sb.append(ss);
   System.out.println(sb);
   }
 }

那么我们使用它的好处在哪呢？还是从底层来分析：

当使用new调用 StringBuilder的无参构造的方式来创建出它的对象，使用对象的append（）来进行字符串的追加，那么他是怎么添加的？

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

可以看到，首先调用了其父类的append（）方法，而且实际上也是由父类的append（）来执行此功能的，最后返回一个它自己，不像String需要去重新赋值才可以看到变化后的内容。那么父类是如何添加字符串？

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

首先会对从StringBuilder对象调用append（）时，传进来的str进行判断，是否有值，如果没值，会进行下面的操作：

  private AbstractStringBuilder appendNull() {
         int c = count;
         ensureCapacityInternal(c + 4);
         final char[] value = this.value;
         value[c++] = 'n';
         value[c++] = 'u';
         value[c++] = 'l';
         value[c++] = 'l';
         count = c;
         return this;
     }

同时会判断传入的str的长度，赋值给int len，

 /**
      * The count is the number of characters used.所使用的字符数----原来的元素长度值，目前为空。
      */
     int count;

下一步就是调用抽象类 AbstractStringBuilder的 ensureCapacityInternal(count + len)方法，关键就在于此，这个方法需要传入两个参数，一个是count,一个是value

 /**
      * The value is used for character storage.这个变量用于字符存储。
      */
     char[] value;

接下来进入ensureCapacityInternal（）方法：

 private void ensureCapacityInternal(int minimumCapacity) {
         // overflow-conscious code
         if (minimumCapacity - value.length > 0) {
             value = Arrays.copyOf(value,
                     newCapacity(minimumCapacity));
         }
     }

这个方法需要传入一个int类型的最小容量值，同样会先做判断，看看这个容量是否能够装下，具体的判断标准就是：把传进来的字符数和原来的元素的长度的和作为最小的需求值，如果需要的值与原本数组长度的值的差大于0，说明原本数组容量不足以容纳实际的字符，接下来重新定义数组并把新的数组赋值给value，此时要调用Arrays的copyof方法，这个方法需要传入两个参数，第一个是原来的数组，第二个是newCapacity(minimumCapacity)方法，此时就涉及到扩容的机制，

在这个 newCapacity()方法中同样需要传入一个最小容量，重新定义数组的容量：

  private int newCapacity(int minCapacity) {
         // overflow-conscious code
         int newCapacity = (value.length << 1) + 2;
         if (newCapacity - minCapacity < 0) {
             newCapacity = minCapacity;
         }
         return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
             ? hugeCapacity(minCapacity)
             : newCapacity;
     }

第一行把数组的长度向左移动一位，也就是扩大2倍，再加2操作，重新赋值给newCapacity，这样就可以把数组的长度扩大满足我们的需求。