java.lang.String源码解析（JDK1.8）

/**
*String实现序列化接口。在序列化接口中并没有任何属性和方法，就用于表示可序列化的VO类
*如果没有实现序列化，Java类的属性值会在程序执行完毕之后被释放，这样就不能将这个
*类进行网络传输，为了能够在以后取出这个对象来使用、传输和保存，可以实现序列化接口，
*将对象写入内存，变成可存储可传输的状态，需要使用的时候就可以进行反序列化，就是
*重新生成相同的对象实例。实现序列化在项目VO类中经常使用到，如果没有实现会报错误
*
*实现 Comparable<String> 用于比较string，String类中有一个CaseInsensitiveComparator类，
*调用compareToIgnoreCase可以实现忽略大小写比较
*/
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence{
    //存储字符，实际使用字符数组存储的，final体现了不可变性
     private final char value[];
     
     //缓存字符串的hashcode，比如在hashmap中，不必每次比较就计算一次hash值
     private int hash; 
     
     //序列化ID
     private static final long serialVersionUID = -6849794470754667710L;
     //将String实例写入ObjectOutputStream中
     private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];
        
     //初始化新创建的字符串，为空字符串。字符串不可变，因此不需要使用此构造函数
     public String() {
        this.value = "".value;
    }
    
    //将参数的值赋给f新创建的字符串
    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }
    
    //将字符数组中的值复制给新创建的字符串
    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }
    
    //从数组的下表为offset的地方复制count个字符给新创建的字符串
    //0< offset < value.length - count，不然会报错
    public String(char value[], int offset, int count)
    
    //将数组转化为字符串
    public String(int[] codePoints, int offset, int count)
    
    //返回索引处的值，如果指定值是Unicode代理的，则返回代理值。
    public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }
    
    //判断是否为空，即长度是否等于零
    public boolean isEmpty(){
        return value.length == 0;
    }
    
    //依次比较value数组中的每个值，如果遇到不相同，就返回false，当传入对象不是
    //String直接返回false
    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;
    }
    //忽略大小写，比较两个字符串是否相等
    public boolean equalsIgnoreCase(String anotherString) {
        return (this == anotherString) ? true
                : (anotherString != null)
                && (anotherString.value.length == value.length)
                && regionMatches(true, 0, anotherString, 0, value.length);
    }
    //通过字典的比较方式，比较两个字符串的大小。比较是基于字符是Unicode编码
    public int compareTo(String anotherString)
    
    //创建一个内部比较类，忽略大小写。该内部Comparator类实现了序列化接口。
    //可以调用compareToIgnoreCase(String str)方法实现忽略大小写比较
    public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    
    //判断字符串是否是以prefix开头或suffix结尾
    public boolean startsWith(String prefix) 
    public boolean endsWith(String suffix)
    
    //获得该字符串的hashCode，在hashmap经常使用
        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;
    }
    //根据regex拆分字符串，会返回空字符串（不包括结尾的空字符串）
    public String[] split(String regex) {
        return split(regex, 0);
    }
    
    //将指定的字符串连接到该字符串的末尾。通过新建字符数组，将字符串里面的字符复制到数组里面，再new 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);
    }
    
    /**
    *jdk1.6中，将这个字符串对象尝试放入串池。
    *如果串池中有，则并不会放入。返回已有的串池中的对象的地址
    *如果没有，会把此对象复制一份，放入串池，并返回串池中的对象地址
    *---------------
    *Jdk1.7起，将这个字符串对象尝试放入串池。
    *如果串池中有，则并不会放入。返回已有的串池中的对象的地址
    *如果没有，则会把对象的引用地址复制一份，放入串池，并返回串池中的引用地址
    *注意两者的区别
    */
    public native String intern();

    还有各种valueOf()和toUpperCase()等等
}