ENUM返回STRING java java返回string类型

String（java.lang.String）

不可变性

• public final class String{xxx…}
• 以final修饰，表示String类不可被继承

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

• 内部为一个char数组，也被初始化为final，一旦被初始化后就不可变。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。

String的连接

@Test 
public void contact () { 
//1连接方式 String s1 = "a"; 
String s2 = "a"; 
String s3 = "a" + s2; 
String s4 = "a" + "a"; 
String s5 = s1 + s2; 
//表达式只有常量时，编译期完成计算 
//表达式有变量时，运行期才计算，所以地址不一样 
System.out.println(s3 == s4); //f 
System.out.println(s3 == s5); //f 
System.out.println(s4 == "aa"); //t 
}

String Pool

字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。

当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。

下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。

String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2);           // false
String s3 = s1.intern();
String s4 = s1.intern();
System.out.println(s3 == s4);           // true

如果是采用 “bbb” 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。

String s5 = "bbb";
String s6 = "bbb";
System.out.println(s5 == s6);  // true

String类型的intern

public void intern () { 
//2：string的intern使用 
//s1是基本类型，比较值。s2是string实例，比较实例地址 
//字符串类型用equals方法比较时只会比较值 
String s1 = "a"; String s2 = new String("a"); 
//调用intern时,如果s2中的字符不在常量池，则加入常量池并返回常量的引用 
String s3 = s2.intern(); 
System.out.println(s1 == s2); 
System.out.println(s1 == s3);
 }

String类型的equals

//重写Object的equals方法
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        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;
    }

String,StringBuffer,StringBuilder，以及对String不变性的理解

• String、StringBuffer、StringBuilder

• 都是 final 类，都不允许被继承
• String 长度是不可变的，StringBuffer、StringBuilder 长度是可变的
• StringBuffer 是线程安全的，StringBuilder 不是线程安全的，但它们两个中的所有方法都是相同的，StringBuffer 在 StringBuilder 的方法之上添加了 synchronized 修饰，保证线程安全
• StringBuilder 比 StringBuffer 拥有更好的性能
• 如果一个 String 类型的字符串，在编译时就可以确定是一个字符串常量，则编译完成之后，字符串会自动拼接成一个常量。此时 String 的速度比 StringBuffer 和 StringBuilder 的性能好的多

• String 不变性的理解

• String 类是被 final 进行修饰的，不能被继承
• 在用 + 号链接字符串的时候会创建新的字符串
• String s = new String(“Hello world”); 可能创建两个对象也可能创建一个对象。如果静态区中有 “Hello world” 字符串常量对象的话，则仅仅在堆中创建一个对象。如果静态区中没有 “Hello world” 对象，则堆上和静态区中都需要创建对象。
• 在 Java 中, 通过使用 “+” 符号来串联字符串的时候,，实际上底层会转成通过 StringBuilder 实例的 append() 方法来实现。

StringBuilder,StringBuffer底层

append

/**
     * The value is used for character storage.
     */
    char[] value;
    //初始化容量为16

    /**
     * Constructs a string builder with no characters in it and an * initial capacity of 16 characters.
     */
    public StringBuilder() {
        super(16);
    }

    //这两个类的append方法都是来自父类AbstractStringBuilder的方法

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

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

    @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

扩容

//注意在append方法中调用到了一个函数
    //ensureCapacityInternal(count +len);
    //该方法是计算append之后的空间是否足够，不足的话需要进行扩容

    public void ensureCapacity(int minimumCapacity) {
        if (minimumCapacity > 0) ensureCapacityInternal(minimumCapacity);
    }

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code 
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value, newCapacity(minimumCapacity));
        }
    }
    //如果新字符串长度大于value数组长度则进行扩容 扩容后的长度一般为原来的两倍 + 2； 
    //假如扩容后的长度超过了jvm支持的最大数组长度MAX_ARRAY_SIZE。
    //考虑两种情况 如果新的字符串长度超过int最大值，则抛出异常，否则直接使用数组最大长度作为新数组的长度。

    private int hugeCapacity(int minCapacity) {
        if (Integer.MAX_VALUE - minCapacity < 0) {
            // overflow
            throw new OutOfMemoryError();
        }
        return (minCapacity > MAX_ARRAY_SIZE) ? minCapacity : MAX_ARRAY_SIZE;
    }

删除

//这两个类型的删除操作：都是调用父类的delete方法进行删除

    public AbstractStringBuilder delete(int start, int end) {
        if (start < 0) throw new StringIndexOutOfBoundsException(start);
        if (end > count) end = count;
        if (start > end) throw new StringIndexOutOfBoundsException();
        int len = end - start;
        if (len > 0) {
            System.arraycopy(value, start + len, value, start, count - end);
            count -= len;
        }
        return this;
    }

    //事实上是将剩余的字符重新拷贝到字符数组value。

用到了system.arraycopy来拷贝数组，速度是比较快的