String源码解读

1.String为什么要用final修饰

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

final表明String类不可被继承，是为了String的安全性，在jvm内存中，字符串被存储在堆中的字符串常量池（StringTable）中，对于相同的字符串，StringTable中只存一份，若String不用final修饰的话，任意一个引用对String类型变量的修改都会导致所有引用的值发生变化，这在Java中是不允许的。

2.String的底层实现

private final char value[];

仅对于jdk8来说，String的底层是char数组，对于更高版本的jdk，String的底层是byte数组，改成byte数组的原因是byte为1字节，而char为2字节，大部分情况下使用1字节足以保证表示的完整性，针对汉字这种2字节的语言，每个汉字使用两个byte表示，因此在jdk9及以后需要制定charset

3.成员变量，缓存字符串的hash值，不需要每次计算，典型的以空间换时间。

private int hash; // Default to 0

4.三种典型的构造方法

    public String() {
        this.value = "".value;
    }

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

jdk8中的构造方法多达15种

5.String.length()的实现

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

可以看出，字符串的长度其实是返回底层char数组的长度

6.isEmpty()的实现

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

可以看出，字符串的长度其实是返回底层char数组的长度是否为0

7.charAt(int index)的实现

    public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }

返回数组中index处的char字符，时间复杂度为O（1）

8.equals(Object anObject)方法

    public boolean equals(Object anObject) {
        if (this == anObject) {//如果内存地址相同，则直接返回true
            return true;
        }
        if (anObject instanceof String) {//如果传入的anObject是String的实例才继续进行判断，否则直接返回false
            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;
    }

9.compareTo(String anotherString)方法

    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) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;//从前往后比，与长度无关
            }
            k++;
        }
        return len1 - len2;//只有完全一样，才比较长度，长度短的小于长度长的
    }

10.CaseInsensitiveComparator 大小写不敏感的外部比较器实现

    private static class CaseInsensitiveComparator
            implements Comparator<String>, java.io.Serializable {//实现外部比较器方法
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {//流程与equals()方法类似
            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) {
                        按理说只需要全部转换为大写就可以，但是因为某些语言(eg 格鲁吉亚语)的大小写转换十分奇怪，所以这里要转换成小写
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

        /** Replaces the de-serialized object. */
        private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
    }

11.compareToIgnoreCase(String str) 大小写不敏感的两字符串比较

    public int compareToIgnoreCase(String str) {
        return CASE_INSENSITIVE_ORDER.compare(this, str);
    }

12.regionMatches(int toffset, String other, int ooffset, int len)  两个字符串的substring进行比较

Params:
    toffset – 本字符串的起始位置.
    other – 另一个字符串.
    ooffset – 另一个字符串的起始位置.
    len – 待比较的substring的长度.
Returns:
    true ：两者的substring完全相同; 
    false：两者的substring不同.

    public boolean regionMatches(int toffset, String other, int ooffset,
            int len) {
        char ta[] = value;
        int to = toffset;
        char pa[] = other.value;
        int po = ooffset;
        // Note: toffset, ooffset, or len might be near -1>>>1.
        if ((ooffset < 0) || (toffset < 0)
                || (toffset > (long)value.length - len)
                || (ooffset > (long)other.value.length - len)) {
            return false;
        }
        while (len-- > 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;
    }

13.regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)两个字符串的substring进行比较（大小写不敏感）

    public boolean regionMatches(boolean ignoreCase, int toffset,
            String other, int ooffset, int len) {
        char ta[] = value;
        int to = toffset;
        char pa[] = other.value;
        int po = ooffset;
        // Note: toffset, ooffset, or len might be near -1>>>1.
        if ((ooffset < 0) || (toffset < 0)
                || (toffset > (long)value.length - len)
                || (ooffset > (long)other.value.length - len)) {
            return false;
        }
        while (len-- > 0) {
            char c1 = ta[to++];
            char c2 = pa[po++];
            if (c1 == c2) {
                continue;
            }
            if (ignoreCase) {
                char u1 = Character.toUpperCase(c1);
                char u2 = Character.toUpperCase(c2);
                if (u1 == u2) {
                    continue;
                }
                //按理说只需要全部转换为大写就可以，但是因为某些语言(eg 格鲁吉亚语)的大小写转换十分奇怪，所以这里要转换成小写
                if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                    continue;
                }
            }
            return false;
        }
        return true;
    }

14.startsWith(String prefix, int toffset)方法，判断从第几位开始是否以prefix为前缀

    public boolean startsWith(String prefix, int toffset) {
        char ta[] = value;
        int to = toffset;
        char pa[] = prefix.value;
        int po = 0;
        int pc = prefix.value.length;
        // Note: toffset might be near -1>>>1.
        if ((toffset < 0) || (toffset > value.length - pc)) {
            return false;
        }
        while (--pc >= 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;
    }

15.startsWith方法的重写，调用startsWith(String prefix, int toffset)方法，toffset为0

    public boolean startsWith(String prefix) {
        return startsWith(prefix, 0);
    }

16.endsWith(String suffix)方法，还是调用了startsWith(String prefix, int toffset)方法

    public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }

17.hashCode()方法

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

如果有缓存的hash值，则直接返回，否则进行计算。以字符串“abcd”为例，String的hashCode()计算过程为

其中，'a' 'b' 'c' 'd'对应的int值分别为97、98、99和100.

18.concat(String str)方法，字符串拼接

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

19 trim()去掉字符串前后的空格

    public String trim() {
        int len = value.length;
        int st = 0;
        char[] val = value;    /* avoid getfield opcode */

        while ((st < len) && (val[st] <= ' ')) {
            st++;
        }
        while ((st < len) && (val[len - 1] <= ' ')) {
            len--;
        }
        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
    }

20.toCharArray() 注意不是直接返回value，而是新建了一个char数组，因为value的修饰符为final，不可编辑

    public char[] toCharArray() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }

21intern()方法 是一个本地方法，用c/c++实现，具体用途为：将字符串常量池中不存在的字符串放到字符串常量池中，提高程序执行效率

public native String intern();