public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {…}

/*字符数组value，存储String中实际字符 */
private final char value[];

/*字符串的哈希值 默认值0*/
private int hash;
/*字符串的哈希值 默认值0*/
/*一个比较器，用来排序String对象,  compareToIgnoreCase方法中有使用 */
public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();

//String str = new String(“123”)
public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
}
//String str3 = new String(new char[] {'1','2','3'});
public String(char value[]) {
         //将字符数组值copy至value
        this.value = Arrays.copyOf(value, value.length); 
    }

public boolean equals(Object anObject) {
        //直接将对象引用相比较，相同返回true
        if (this == anObject) {
            return true;
        }
        //比较当前对象与anObject的字符序列value
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        //取长度较小的字符串的长度
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;
        int k = 0;
        while (k < lim) {
            //将两个字符串的字符序列value逐个比较，如果不等，则返回该位置两个字符的Unicode 之差
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2; //返回Unicode 之差
            }
            k++;
        }
        //长度较小的字符串所有位都比较完，则返回两个字符串长度之差
        //如果两个字符串相同，那么长度之差为0，即相同字符串返回0
        return len1 - len2;
    }

public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

        String str1 = new String("123");
        String str2 = "123";
        String str3 = "123";
        String str4 = str1.intern();
        System.out.println(str1==str2); // false str1在堆中创建对象，str2在常量池中创建对象
        System.out.println(str2==str3); // true  str2在常量池中创建对象,str3直接返回的str2创建的对象的引用 所以str2和str3指向常量池中同一个对象
        System.out.println(str4==str3); // true  str4返回常量池中值为"123"的对象，因此str4和str2、str3都相等

public class StringTest {
    public static final String X = "ABC"; // 常量X
    @Test
    public void Test() {
        String str5 = new String("ABC");
        String str6 = str5+"DEF";    //堆中创建
        String str7 = "ABC"+"DEF";   //常量池
        String str8 = X+"DEF";       //X为常量,值是固定的,因此X+"DEF"值已经定下来为ABCDEF，实际上编译后得代码相当于String str8 = "ABCDEF"
        String str9 = "ABC";       
        String str10 = str9+"DEF";  //堆中
        
        System.out.println(str6==str7); //false
        System.out.println(str8==str7); //true
        System.out.println(str10==str7); //false
        
    }
}

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

         String str1="123";
         String str2="456";
         String str3="789";
         
         String str4 = "123" + "456" + "789"; //常量相加，编译器自动识别 String str4=“123456789”
         
         String str5 = str1 + str2 + str3;  //字符串变量拼接，推荐使用StringBuilder
         
         StringBuilder sb = new StringBuilder();  
            sb.append(str1);
            sb.append(str2);
            sb.append(str3);

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
    //拼接字符串
    @Override
    public StringBuilder append(String str) {

   //调用父类AbstractStringBuilder.append
   super.append(str); return this; 
  } 
}

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * 存储字符串的字符数组，非final类型，区别于String类
     */
    char[] value;
    /**
     * The count is the number of characters used.
     */
    int count;
    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
         //检查是否需要扩容
        ensureCapacityInternal(count + len);
        //字符串str拷贝至value        
        str.getChars(0, len, value, count);
        count += len;
        return this;
}
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        // minimumCapacity=count+str.length
        //拼接上str后的容量 如果 大于value容量，则扩容
        if (minimumCapacity - value.length > 0) {
                
             //扩容，并将当前value值拷贝至扩容后的字符数组，返回新数组引用
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
    //StringBuilder扩容
    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        // 计算扩容容量
        // 默认扩容后的数组长度是按原数（value[]）组长度的2倍再加上2的规则来扩展,为什么加2？
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }
}