java中String、StringBuffer、StringBuilder的区别

String result = "";  
for (String s : hugeArray) {  
    result = result + s;  
}  

                public
                final
                class
                 String
    
                implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */privatefinalchar value[];//final类型char数组
//省略其他代码…………
}

                public String substring(int beginIndex) {
        if (beginIndex < 0) {
            thrownew StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            thrownew StringIndexOutOfBoundsException(subLen);
        }
       //当对原来的字符串进行截取的时候（beginIndex >0），返回的结果是新建的对象return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }

                abstract
                class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */char[] value;//一个char类型的数组，非final类型，这一点与String类不同/**
     * This no-arg constructor is necessary for serialization of subclasses.
     */
    AbstractStringBuilder() {
    }

    /**
     * Creates an AbstractStringBuilder of the specified capacity.
     */
    AbstractStringBuilder(int capacity) {
        value = newchar[capacity];//构建了长度为capacity大小的数组    }

//其他代码省略…………
}

                public
                final
                class
                 StringBuffer
    
                extends
                 AbstractStringBuilder
    
                implements
                 java.io.Serializable, CharSequence
{
   
                /**
                
     * Constructs a string buffer with no characters in it and an
     * initial capacity of 16 characters.
     
                */
                public
                 StringBuffer() {
        
                super(16);//创建一个默认大小为16的char型数组    }

    /**
     * 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);//自定义创建大小为capacity的char型数组    }
//省略其他代码……
……

                public
                class
                 Test{
  
                public
                static
                void
                 main(String args[]){
    StringBuffer sBuffer = new StringBuffer("hello");
    sBuffer.append(" ");
    sBuffer.append("world");
    System.out.println(sBuffer); 
  }
}

hello world

                public
                 AbstractStringBuilder append(String str) {
        
                if (str == null)
            return appendNull();
        int len = str.length();
       //调用下面的ensureCapacityInternal方法
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        returnthis;
    }

privatevoid ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious codeif (minimumCapacity - value.length > 0)
           //调用下面的expandCapacity方法实现“扩容”特性            expandCapacity(minimumCapacity);
    }

   /**
     * This implements the expansion semantics of ensureCapacity with no
     * size check or synchronization.
     */void expandCapacity(int minimumCapacity) {
       //“扩展”的数组长度是按“扩展”前数组长度的2倍再加上2 byte的规则来扩展int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflowthrownew OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        //将value变量指向Arrays返回的新的char[]对象，从而达到“扩容”的特性
        value = Arrays.copyOf(value, newCapacity);
    }

                public
                static
                char[] copyOf(char[] original, int newLength) {
        //创建长度为newLength的char数组，也就是“扩容”后的char 数组，并作为返回值char[] copy = newchar[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;//返回“扩容”后的数组变量
    }

                public
                synchronized
                 StringBuffer reverse() {
    
                super
                .reverse();
    
                return
                this
                ;
}


                public
                int
                 indexOf(String str) {
    
                return indexOf(str, 0);        //存在 public synchronized int indexOf(String str, int fromIndex) 方法
}