JSK1.8 String类部分关键源码分析

本文基于JDK1.8中的String类，看源码时无意发现String类中几个比较有意思的地方，特此记录下。

String类的两个重要属性，final的字符数组和int的hash值，还有序列化相关的两个字段，这里不写；

final char value[]初始化后将是不可以变的，与String类的final关键字相呼应，保证的字符串的不变性；特别是在初始化字符串对象时，如果常量池中存在该字符串，可以将value直接指向常量池中的字符串，这样既节省内存又方便，同时由于是final类型，也没有多线程并发问题。

private int hash在JVM中，int类型默认初始化为0，在未调hashCode时hashCode一直是0，只有在调一次时还会生成。

    /** The value is used for character storage. */
    private final char value[];        

    /** Cache the hash code for the string */
    private int hash; // Default to 0

hashCode()方法：

    // hashCode生成规则，s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {    // 只有第一次调用时才会生成一个hashCode并赋值
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

compareTo()方法， 这个方法有意思的地方在while循环中，return c1 - c2，这种写法，直接通过字符的ASCII码相减得到一个int值，进行返回，高下立判断：

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

构造方法String(String original)，通过String构造自身的构造方法，省事，不需要通过Arrays.copyOf重新做一份copy，直接应用之前String类的value和赋值hash值，反正是final的：

public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

intern()方法，这是个本地方法，通过此方法可以将字符串数组放到方法区（不同JDK版本方法区叫法位置可能不一样，这也是需要研究的），合适的时候调用intern方法，可以减少创建对象的个数，减少内存开销（共用了内存啊）。

 public native String intern();

**substring(int beginIndex)方法，**截取子字符串，可以看出在JDK1.8中截取字串是依赖于根据原字符串的字符串数组，通过copy操作生成字串的字符串数组，即char value[]：

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[] split(String regex, int limit)，split方法，String类中比较重要的而且容易埋坑出错的方法：

public String[] split(String regex, int limit) {
    /* 
      第一种情况：
     (1)只有一个字符，并且这个字符非正则表达式中的元字符，即非正则表达式中的特殊字符
     (2)只有两个字符并且第一个字符是转义字符，第二个字符是非数字，字母的以及以及utf-16之间的字符，换而言之，由于条件1中规定了非正则表达式的特殊字符，如果是用了正则表达式的特殊字符，并且转义了，将匹配这一项
     第二种情况使用正则表达式进行分割；
     */
    char ch = 0;
    if (((regex.value.length == 1 &&
         ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||      // 
         (regex.length() == 2 &&
          regex.charAt(0) == '\\' &&
          (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
          ((ch-'a')|('z'-ch)) < 0 &&
          ((ch-'A')|('Z'-ch)) < 0)) &&
        (ch < Character.MIN_HIGH_SURROGATE ||
         ch > Character.MAX_LOW_SURROGATE))
    {
        int off = 0;
        int next = 0;
        boolean limited = limit > 0;        // 如果有填写limit,并且大于0
        ArrayList<String> list = new ArrayList<>();
        while ((next = indexOf(ch, off)) != -1) {   
            if (!limited || list.size() < limit - 1) {  // 如果没有配置限制，或者有配置限制的情况，拆分结果list没有超过限制的情况
                list.add(substring(off, next));      // list中添加字串
                off = next + 1;
            } else {    // last one                        // 如果有分段个数限制，并且是最后一个
                //assert (list.size() == limit - 1);
                list.add(substring(off, value.length));         //把后面剩余的全部放入
                off = value.length;
                break;
            }
        }
        // If no match was found, return this
        if (off == 0)             // 如果有没有分割符号，完整返回
            return new String[]{this};

        // Add remaining segment
        if (!limited || list.size() < limit)            // 如果没有限制或者结果大小小于限制个数
            list.add(substring(off, value.length));

        // Construct result
        int resultSize = list.size();         // 构造结果，最终的结果在这下面生成
        if (limit == 0) {                // 在没有限制的情况下
            while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {   // 后面所有的空串都会被清掉
                resultSize--;
            }
        }
        String[] result = new String[resultSize];             // 这里生成最终结果
        return list.subList(0, resultSize).toArray(result);
    }
    return Pattern.compile(regex).split(this, limit);
}

坑就在，在没有限制的情况下，拆分出来的部分，如果后面部分为空串，这些空串都会被抛弃。很多项目中都喜欢用split(",")，如果拆分出的后几段是空，数组的长度是不够的，这样会存在数组越界异常。

以下有时间再整理出两篇关于String中split中的坑的问题，以及常见的那种创建字符串是会创建几个对象的问题，即字符串常量池问题，再之后是JDK个版本中JVM内存模型及相关变化，仅供记录。