String、String.intern()方法、StringBuilder和StringBuffer的深入理解与总结

一、String类的一些基础知识和要点

1. String类和字符数组是被fianl修饰的

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
   
    /** The value is used for character storage. */
    private final char value[];

观察String类的源码可以很容易得出结论：

• String类是被final修饰的，意味着该类不能被继承
• 通过char[] value数组来保存字符串，该字符数组也被final所修饰，所以这是String字符串不可变的本质原因

下面来看该类中对于字符串操作的一些相关方法

2. String类中字符串的操作方法返回的都是新对象

public String substring(int beginIndex, int endIndex) {
   
        if (beginIndex < 0) {
   
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
   
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
   
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }
public String concat(String str) {
   
        int otherLen = str.length();
        if (otherLen == 0) {
   
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }
     public String replace(char oldChar, char newChar) {
   
        if (oldChar != newChar) {
   
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            while (++i < len) {
   
                if (val[i] == oldChar) {
   
                    break;
                }
            }
            if (i < len) {
   
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
   
                    buf[j] = val[j];
                }
                while (i < len) {
   
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

很容易得出结论：

• sub操、concat还是replace操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，最原始的字符串并没有被改变。
• 对String对象的任何改变都不影响到原对象，任何相关的改变操作都会生成新的对象

二、String的不同创建方式的以及intern()方法的深入理解

1. String的不同创建方式

对于这个问题的阐述通过一个示例来进行：

• 请考虑下述代码的输出并分析原因

public static void main(String[] args)