String源码阅读之contains实现原理

转载请注明出处：http://blog.csdn.net/jevonsCSDN/article/details/60758197 【Jevons’Blog】

本文将对String部分源码进行阅读分析的记录。

contains

对String中的contains方法进行分析，了解其采用的是什么算法进行匹配。

//用于判断源字符串是否包含目标字符序列 CharSequence s
 public boolean contains(CharSequence s) {
         //调用indexOf(String str)方法
        return indexOf(s.toString()) > -1;
    }

indexOf (String str)

    public int indexOf(String str) {
    //继续往下调用indexOf(String str, int fromIndex)方法，并传入匹配起始下标
        return indexOf(str, 0);
    }

indexOf (String str, int fromIndex)

    public int indexOf(String str, int fromIndex) {
        //继续往下调用indexOf(char[] source, int sourceOffset, int sourceCount,char[] target, int targetOffset, int targetCount,int fromIndex) 函数
        //传入源字符串，源字符串偏移量，源字符串长度，目标字符串，目标字符串偏移量，目标字符串长度，匹配源字符串的起始坐标
        return indexOf(value, 0, value.length,
                str.value, 0, str.value.length, fromIndex);
    }

indexOf (char[] source, int sourceOffset, int sourceCount,char[] target, int targetOffset, int targetCount,int fromIndex)

static int indexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount,
            int fromIndex) {
         //若匹配的起始下标大于或等于源字符串的长度
        if (fromIndex >= sourceCount) {
            //检测目标长度是否为0，是则返回源字符串长度，否则返回-1
            return (targetCount == 0 ? sourceCount : -1);
        }
        //若匹配的起始下标小于0
        if (fromIndex < 0) {
            //将匹配的起始下标置0
            fromIndex = 0;
        }
        //若目标字符串长度等于0
        if (targetCount == 0) {
            //直接返回匹配的起始下标
            return fromIndex;
        }
        //从定义的目标偏移量中取出目标字符串的第一个字符
        char first = target[targetOffset];
        //获取源字符串能被匹配的最大长度
        int max = sourceOffset + (sourceCount - targetCount);
        //从定义的偏移量加上起始匹配下标开始进行匹配
        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            /* Look for first character. */
            //检测第一个字符是否相等
            if (source[i] != first) {
                //不相等则循环匹配，直到找到能与目标字符串第一个字符匹配的源字符串下标。
                while (++i <= max && source[i] != first);
            }

            /* Found first character, now look at the rest of v2 */
            //已经找到了与目标字符串第一个字符匹配的源字符串下标，则从该下标的下一位开始，对目标字符串余下的字符进行匹配。
            if (i <= max) {
                //从该下标的下一位开始
                int j = i + 1;
                //定义本次匹配的最大长度
                int end = j + targetCount - 1;
                //循环匹配
                for (int k = targetOffset + 1; j < end && source[j]
                        == target[k]; j++, k++);
                //j能一直增加到end，说明已经成功匹配
                if (j == end) {
                    /* Found whole string. */
                    //返回在源字符串中被匹配到的第一个字符的下标。
                    return i - sourceOffset;
                }
            }
        }
        //没有匹配到，返回-1
        return -1;
    }

　　从这个方法中可以看出，其采用的是最原始也是最笨的方法进行匹配，将目标字符串与源字符串的字符进行逐一匹配，若第一个字符匹配成功，则进行余下的匹配，若余下的匹配不成功，则从一开始目标字符串的第一个字符与源字符串匹配时的下标的下一位继续进行匹配。这样其实是浪费了很多没必要的时间。有关字符串匹配的快捷有效匹配算法，可以参照KMP算法。