Java String的部分源码学习

String类的源码比较简单，但也还是包含了很多的方法，这里挑常见的部分写写自己的理解。

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

    /** Cache the hash code for the string */  
    private int hash; // Default to 0  
    }

String是一个final类，所以我们不能继承String类，也不能对其中的方法进行改写。String有一个私有的final字符数组，用来保存我们的字符串，另一个私有int变量hash，用来保存hashcode。所以，我们可以知道，大部分对于String的操作，其实都是对数组进行操作，而字符数组被声明为final，故我们不能对它进行改写，一旦，我们的String对象的内容有所变化，很多都是重新生成了一个字符数组。

String类的构造函数有很多，包括无参数的构造函数，参数为String对象的构造函数，参数为数组的构造函数，使用数组的部分内容来构造，以及通过Unicode，ASCII，StringBuffer，StringBuilder来构造，等等。

    public String() {  
        this.value = new char[0];  
    }  
    public String(String original) {  
        this.value = original.value;  
        this.hash = original.hash;  
    }
    public String(char value[]) {  
        this.value = Arrays.copyOf(value,      value.length);  
    } 

以上代码可以看出：

1. 如果使用使用无参的构造函数，例如，String str = new String（）；那么得到的String对象中的数组长度是0
2. 如果使用String对象来初始化，那么，初始化后的String对象和原来的String对象的hash是一样的。

3. 如果使用数组来初始化，最后得到的String对象的内容是对原来数组的拷贝。

   那么，如果使用StringBuffer和StringBuilder来初始化，又是什么情况呢？

    public String(StringBuffer buffer) {  
        synchronized(buffer) {  
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());  
        }  
    } 
    public String(StringBuilder builder) {  
        this.value = Arrays.copyOf(builder.getValue(), builder.length());  
    }

这两种方法构造出来的String对象同原来的String对象也不是同一个引用，而且，与StringBuffer和StringBuilder的特性一致，StringBuffer对buffer对象使用sychronized，是线程安全的。

String可以通过length方法来获取字符串的长度，它的实现就是返回了内部字符数组的length属性值。

    public int length() {  
        return value.length;  
    }

同理，如何判断一个String对象是不是空呢，即判断字符数组的长度是否为空。

    public boolean isEmpty() {  
        return value.length == 0;  
    }

下面看一下String是如何实现equal方法的。

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

equal的对比，首先，判断是否是同一个对象的引用。如果传入的参数的类型也是String，那么再对比两个字符串的长度，如果长度相同，再通过循环来比较每一个数组上每一个位置的值是否相同。String还提供了一个contentEquals方法来对比字符串和一个CharSequence的内容是否一致。

在比较两个字符串方面，有compareTo和compareToIgnoreCase两个方法，顾名思义，前者会严格对比每一个字符是不是一致，而后者会忽略大小写的影响。

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

如何忽略大小写呢，如果当同一位置的字符不相等的时候，同时转成大写或小写，再进行比较。（不过，为什么转大写之后，如果不等为什么还会尝试转一次小写呢？）

    public int hashCode() {  
        int h = hash;  
        if (h == 0 && value.length > 0) {  
            char val[] = value;  

            for (int i = 0; i < value.length; i++) {  
                h = 31 * h + val[i];  
            }  
            hash = h;  
        }  
        return h;  
    } 

上面列出了String的hashcode算法。这里采用的是直接寻址法，RSHash。

通常情况，我们会把String，StringBuilder，StringBuffer做比较，得出的结论是，如果事后要对String尾部进行添加操作，String是最慢的。这里，可以看下String的具体实现。

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

可以看出，实际上是重新声明了一个长度为两者之和的数组，然后将value拷贝进去，最后用这个数组去初始化一个String对象，所以，最后的结果是会新生成一个String对象，并将新的引用返回。比起另两种直接在数组上操作的方法相比，new一个对象的开销明显更大。