JDK源码——String（二）

系列文章目录

JDK源码——String（一）

---

3.普通方法（接上一节）

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

override了comparable接口的compareTo方法，用于指定两个字符串对象之间的大小关系

首先，获取了两个字符串内部字符数组的长度，也即两个字符串的长度，并得到较短的那个字符串的长度

然后，我们通过循环比较两个字符串共有长度的各个位置的字符，如果这部分里面有不一样的字符，则直接返回不一样的这两个字符的大小关系，直到循环结束，也就是共有部分都相同

最后，离开了循环说明这两个字符串共有的部分是相同的，那么也就是说，更长的那个字符串是更大的，因此这里就直接返回两个的长度差值

public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                     = new 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) {
        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) {
                    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; }
}

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

这里定义了一个忽略大小写的比较器，具体逻辑同上述相似，只不过在循环内部比较的时候会在保证两字符不相等，大写不相等，小写也不相等的三个条件都满足时才认为不相等。

这里提两点

• 一，为什么要这么复杂，直接比小写或者大写不就可以了吗？官方给的解答是存在某一些小语种中不存在大写或者小写，或者大小写转换有别于英语因此都需要比较
• 二，Numeric promotion什么意思，这里整句话是说因为数值类型的提升，不会出现overflow的情况，解释一下就是，我们在进行byte，char，int等数值类型的运算时，有必要的话会自动向上也就是更大的数值类型转换，这种转换就不会导致overflow

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

这是一个比较字串是否相等的方法，toffset指从当前String对象的哪个位置开始比较，ooffset指other字符串的哪个位置开始比较，len指比较的长度

首先是一个防御编程，如果出现了ooffset小于0，toffset小于0，或者两个字符串选定的范围即offset + len超过了字符串的长度的情况，都返回false

然后就是一个个的比较，因为长度是相同的，所以挨个比较字符就行

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) {
            // If characters don't match but case may be ignored,
            // try converting both characters to uppercase.
            // If the results match, then the comparison scan should
            // continue.
            char u1 = Character.toUpperCase(c1);
            char u2 = Character.toUpperCase(c2);
            if (u1 == u2) {
                continue;
            }
            // Unfortunately, conversion to uppercase does not work properly
            // for the Georgian alphabet, which has strange rules about case
            // conversion.  So we need to make one last check before
            // exiting.
            if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                continue;
            }
        }
        return false;
    }
    return true;
}

同上面的比较两个字符串的方法一样，这个字串匹配的方法也设有一个忽略大小写的比较逻辑，和之前一样也是在三个比较都不成立的情况下才认为两个字符不相同，这里也交代了上面说到的这种奇怪比较的理由

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

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

这里的两个方法是用来看当前字符串是否以prefix为前缀，toffset用来指定从哪个位置开始

具体逻辑仍然是先防御性变成判断toffset的合理性，然后逐字符的比较，全部相等就返回true

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

通过运用上一个方法，比较后缀，只不过指定了相应的偏移量

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

重点方法，hashCode的计算

首先，就是对于hash值的缓存问题，一开始我们发现String里面hash字段并没有初始化，也就是说一直都是0，直到某一时刻我们调用了hashCode()函数，在hash == 0且当前字符串不是空串的时候才进行一波计算，之后如果再次调用就直接返回缓存好的hash值

然后，我们来关注求值的过程

这是一个迭代的表达式 h = 31 * h + val[i]，形象一点来看，hash = s[0] * 31 ^ (n-1) + s[1] * 31 ^ (n - 2) + … + s[n-1] * 31 ^ 0

这里就有一个疑问，为什么是31，理论上这里不是31仍然可以达到求取hash的过程，具体理由可能有如下几点：

1. 31作为乘数，乘法运算时能被JVM优化 n * 31 = n * 32 - n = (n << 5) - n，而对于计算机而言移位运算是硬件层次上的运算，更高效

2. 离散数学理论有证明，我们需要一个不大不小的质数，这样的数能够让hash散列分布的更均匀

3. 从统计学的角度讲，我们常用的英语单词中，通过31的散列效果是非常好的（常用单词在Unix下存储在/usr/share/dict/words）具体的效果可视化可以参见这位大大的博客科普：为什么 String hashCode 方法选择数字31作为乘子 - SegmentFault 思否

    public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }

    public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }

substring截取字符串的函数，指定一个参数时，我们从这个位置起截取至末尾，指定两个参数时我们截取这两个索引包含的部分（包头不包尾）

我们先看指定一个参数的情况，先判断beginIndex的合理性，小于0或者大于字符串长度直接抛出异常

然后，判断beginIndex是不是0，是的话直接返回自己，不是就通过构造函数构造一个子字符串

• 这里有一个点很有意思，为什么不直接构造要来判断截取的字符串是不是自己本身呢？这就得回到之前提到的字符串的唯一性，同一个字符序列我们规定只存在一个String对象，这里正是这个规定或者说内部逻辑的体现之处

两个参数的逻辑一样，只不过需要检验的参数合理性要多一个，然后后续关于是否是自身的判断多了一个条件，其他的都一样

public String concat(String str) {
    if (str.isEmpty()) {
        return this;
    }
    int len = value.length;
    int otherLen = str.length();
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

concat拼接字符串

首先判断拼接的字符串是不是空串，空串的话同substring讲到的道理需要直接返回自己

然后，我们先讲自身拷贝到一个字符数组中，并且这个字符数组指定了len + otherLen的长度，然后通过前面讲到的getChars的方法，从len出开始将str的字符数组copy到buf数组中，这个函数以及后面关于直接赋值的构造函数的讲解可以见上一章

最后我们通过直接赋值的那一个构造函数来构造一个新的String对象，由于这个buf数组是我们在这里新创建的，所以运用这种构造函数没有破坏不可变性的可能，且更加快速

public String replace(char oldChar, char newChar) {
    if (oldChar != newChar) {
        int len = value.length;
        int i = -1;
        char[] val = value; /* avoid getfield opcode */

        while (++i < len) {
            if (val[i] == oldChar) {
                break;
            }
        }
        if (i < len) {
            char buf[] = new char[len];
            for (int j = 0; j < i; j++) {
                buf[j] = val[j];
            }
            while (i < len) {
                char c = val[i];
                buf[i] = (c == oldChar) ? newChar : c;
                i++;
            }
            return new String(buf, true);
        }
    }
    return this;
}

replace方法

将字符串中所有的某个字符替换成新字符

实现逻辑也很简单，先找到第一个oldChar出现的位置，然后将这个位置之前的值全部复制到新的char数组中，随后的字符，再来判断是否和oldChar相等，相等就替换

最后构造一个新的String

public boolean matches(String regex) {
    return Pattern.matches(regex, this);
}

用的是正则表达的另一个类的静态方法判断

public boolean contains(CharSequence s) {
    return indexOf(s.toString()) > -1;
}

用的是方法indexOf，找出这个s所在的位置，如果大于-1证明找到了

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

去掉前后空白的方法

两个指针，从两个方向开始直到第一个不为‘ ’ 的位置停下，最后把这两个指针之间的字串使用substring方法截取出来，如果字符串前后都没有空，证明是同一个字符串，那么直接返回自己就可以

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

将自己的char数组复制一份返回，因此对返回的数组的修改并不会影响字符串本身

4.String类的特性——不可变性

4.1.什么叫不可变？

从之前对方法的分析我们也不难看出，从某一个String对象的产生开始，我们后续就没有办法改变这一个已经创建好的字符串的字符数组，即这一个字符序列与这一个对象绑定在了一起

4.2怎么实现的不可变？

这个是String这个类的众多设计共同促使的结果

• String类被final修饰，当一个类被final关键字修饰之后，将不再有类能够继承String，带来的直接好处是String的所有方法不能够被重写，所有逻辑都有jdk把控
• 实际存储字符的字符数组字段被声明为了 private final char value[] ，用private修饰代表外界不能直接访问字段，final修饰代表所有对这个字符数组的操作都不能改变value的值即为一个常量
• String的构造函数们。从我们之前介绍的所有构造函数中可以发现，提供给外部访问的构造函数最终的逻辑都是通过拷贝的方式建立String对象，因此即使我将外部char数组等变量改变了，仍然不会影响到所创建的String对象里面的char数组
• String的普通方法们。所有String的普通方法，但凡涉及到会改变String内容的都会有一个判断逻辑，如果经过函数处理其实字符串没有改变，我们直接返回this，保证了同一个字符序列只有一个对象；如果改变了，那么我们一定会创造一个新的char数组，将新值写入并创建一个新的且char数组指针指向这个拷贝好的数组的String对象

4.3不变性的好处

• 字符串常量池。如果我们想要实现一个字符串常量池，让同一个字面值的所有字符串在内存空间都指向同一片堆内存，那么我们必须保证字符串不可变，逻辑交予jvm执行
• 线程安全。字符串的不可变直接保证了字符串的线程安全，所有线程看到的字符串实例都是同一片内存区域，因此同一个字符串能被多个线程安全的共享
• 缓存hash。之前看hashCode源码时我们发现，只有第一次调用该方法才会求解hash值，之后直接使用之前计算缓存好的hash，避免了大量的重复计算，因此也使得String作为HashMap的Key时表现更优秀，具有更好的性能