String源码解读笔记

学海无涯，回头无岸。从源码上学习String，并做下笔记～

可以从以上源码看出：

String对象是不可变量

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

String类被final所修饰，也就是说String对象是不可变量，并发程序最喜欢不可变量了。String类实现了Serializable, Comparable, CharSequence接口。

字符串相等对比equals做了什么

public boolean equals(Object anObject) {
    // 判断是否引用的是同一个对象，如果是直接返回真
    if (this == anObject) {
        return true;
    }
    // 判断对比的两个对象是否是都是String对象，如果不是直接返回false
    if (anObject instanceof String) {
        String anotherString = (String) anObject;
        int n = value.length;
        // 如果String对象的char数组长度不相等，返回假
        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;
}

可以直接从代码中看出eqauls操作的流程~

看看compareTo对比两个对象的时候做了什么

int compareTo(String anotherString)

public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    // 取两个进行比较的字符串长度的最小值lim
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    // 从第一个字符开始到最小长度lim处为止，如果字符不相等，返回对象不相等处字符-被比较对象不相等字符，即AB AC 对比的时候用B-C
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    // 如果说相等长度的字符串都相等了，则返回自身长度-被比较对象长度，长的肯定就大了
    return len1 - len2;
}

这里一个对比的过程是这样的：先获取两个字符串中最短的长度，然后从第一个字符开始对比，对比到这个长度为止，这个过程中如果哪个字符不想等，则直接用两个进行相减，如果全程高能都相等，则最后用两个的长度进行对比。。所以这里会出现一种情况，那就是字符串“1235”要大于“123456”。

看看hashCode做了什么

public int hashCode() {
    // hash默认为0
    int h = hash;
    // 如果hash没有被计算过，并且字符串不为空，则进行hashCode计算
    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方法。我们可以从计算过程中看出来，不相同的字符串也可能得出同样的hash，所以这也证明了hashCode相同，字符串不一定相同的理论。

看看intern方法是什么鬼

public native String intern();

可以从代码中看出来，intern方法是native调用，作用是在方法区中的常量池里通过equals方法获取等值的对象，如果没有找到则在常量池中开辟一片空间存放字符串并返回该对应String的引用，否则直接返回常量池中已存在String对象的引用。
这里添加个demo直观的感受下intern()；

public class Main {

    public static void main(String[] args){
        String c = "ab1";
        String a = new String("ab1");
        String b = new String("ab1").intern();
        System.out.println(a == b);
        System.out.println(a == c);
        System.out.println(b == c);

    }
}

返回结果为false false true，可以看出b从常量池获取了字符串。

最后编辑于：2018.04.10 23:34:41