String源码学习笔记-API

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }//第一步先比较对象地址如果地址相同则返回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;
    }

private int hash; // Default to 0
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类中，有个字段hash存储着String的哈希值，如果字符串为空，则hash的值为0。String类中的hashCode计算方法就是以31为权，每一位为字符的ASCII值进行运算，用自然溢出来等效取模，经过第一次的hashcode计算之后，属性hash就会赋哈希值。从源码的英文注释可以了解到哈希的计算公式：s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]

		String a = "gdejicbegh";
        String b = "hgebcijedg";
        System.out.println("a.hashcode() == b.hashcode() " + (a.hashCode() == b.hashCode()));
        System.out.println("a.equals(b) " + (a.equals(b)));
        a.hashcode() == b.hashcode() true
		a.equals(b) false

如果两个对象equals()，则它们的hashcode一定相等。
如果两个对象不equals()，它们的hashcode可能相等。
如果两个对象的hashcode相等，则它们不一定equals。
如果两个对象的hashcode不相等，则它们一定不equals。

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

从compareTo()的源码可知，这方法时先比较两个字符串内的字符串数组的ASCII值，如果最小字符串都比较完了都还是相等的，则返回字符串长度的差值；否则在最小字符串比较完之前，字符不相等，则返回不相等字符的ASCII值差值。

public int indexOf(int ch, int fromIndex) {
        final int max = value.length;
        if (fromIndex < 0) {
            fromIndex = 0;
        } else if (fromIndex >= max) {
            // Note: fromIndex might be near -1>>>1.
            return -1;
        }

        if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
            final char[] value = this.value;
            for (int i = fromIndex; i < max; i++) {
                if (value[i] == ch) {
                    return i;
                }
            }
            return -1;
        } else {
            return indexOfSupplementary(ch, fromIndex);
        }
    }

对于String的indexOf(int ch)方法，查看其源码可知其方法入参为ASCII码值，然后和目标字符串的ASCII值来进行比较的。其中常量Character.MIN_SUPPLEMENTARY_CODE_POINT表示的是0x010000——十六进制的010000，十进制的值为65536，这个值表示的是十六进制的最大值。