JDK1.8之String

今天写一下String类。这个类被广泛且大量的用到，写它的目的在于熟练掌握常用方法，熟悉String拥有的方法以便于在以后能够想起来，用到。不多说，开码！！！

• equals方法。我们来翻译下注释：将这个字符串与特定对象进行比较，相同返回true不相同返回false。下面来分析代码

    public boolean equals(Object anObject) {
        //判断一个对象是否为空
        // 写api的时候，需要有一个思想
        // 不要信任任何入参，所以拿到入参需要做基础的空校验。
        if (this == anObject) {
            return true;
        }
        //判断入参是否是String的一个实例
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            //调用equals方法的字符串长度
            int n = value.length;
            //判断是否等于传入字符串的长度
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                //i从0开始循环至n-1（也就是字符串的长度）
                while (n-- != 0) {
                    //比较每一个字符是否相等。
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

看到上面的equals方法，一定回想知道，equalsIgnoreCase方法是如何实现不许分大小写的呢？接下来，上源码

• equalsIgnoreCase方法

    public boolean equalsIgnoreCase(String anotherString) {
        //不解释了，直接进入主题，方法的核心在于regionMatches方法。往下看
        return (this == anotherString) ? true
                : (anotherString != null)
                && (anotherString.value.length == value.length)
                && regionMatches(true, 0, anotherString, 0, value.length);
    }

    /**
     *
     * @param ignoreCase 忽略大小写的一个标记位，入参设置为true
     * @param toffset
     * @param other 相比较的对象
     * @param ooffset
     * @param len
     * @return
     */
    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;
                }
                //如果都为大写，还是不相等，那就都转小写。
                //为什么要做两次比较呢？
                //a A都转大写之后，不应该相等了吗？
                //看不明白了。。。
                if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                    continue;
                }
            }
            return false;
        }
        return true;
    }

看到这 不禁想问，为什么还要转小写再比较？遗留问题1 。看到这里，会想到，与equals想类似的方法，compareTo，上代码

• compareTo方法，比较两个字符串。调用对象与欲比较对象

    //compareTo方法，比较对应位置上两个字符的大小。
    public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        //取出两字符串长度，选择最短的。
        //Math.min方法就是个三目运算符。不解释，咳咳
        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) {
                //返回>0则调用对象大于欲比较对象，<0则反之
                return c1 - c2;
            }
            k++;
        }
        //若上述判断相等，则长的大。这里很清晰的看到，这样一个逻辑：
        //首先以每个位置的字符大小为准，其次才是比较长度。（咳咳  这里是重点要考滴）
        return len1 - len2;
    }

当然啦，肯定是有忽略大小写的比较方法滴，类似。不解释。

• 下面来看看另一个比较常用方法replace

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

            //找出第一个需要替换的字符的位置i
            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                //将i之前的字符放入新的字符数组中
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                //循环i以及i之后的字符，凡是跟需要替换的字符相等滴，全部替换成新的字符
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                //返回一个新的字符串
                return new String(buf, true);
            }
        }
        return this;
    }

与之类似方法有replaceFirst和replaceAll方法，区别在于，replaceAll方法传入为正则，遇到斜杠会进行转义，而replace不会。

• 下面来看另一个常用方法split。

哇 说起这个方法，就厉害了，实现长的要死。。。看的真费劲 ，所以决定分割出来看。咳咳---水平不行

    public String[] split(String regex, int limit) {
        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;
            ArrayList<String> list = new ArrayList<>();
            while ((next = indexOf(ch, off)) != -1) {
                if (!limited || list.size() < limit - 1) {
                    list.add(substring(off, next));
                    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);
    }

• 看看去空格方法吧，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;
    }