最近项目中用到了字符串比较，要求省份--城市--区域与地址做对比，如果地址包含区域的字符串就返回true.

我的实现方式是打算用将两个字符串每一个字符进行比较，直到省份--城市--区域遍历完毕。

这么做问题的确是解决了，但是我想到String类库里面indexOf是能解决了，但是我也不甘于仅仅是使用类库，因此我打算看下indexOf源码。

 /**
*获取字符串的的位置
**/
 public int indexOf(String str) {
        return indexOf(str, 0);
    }


/**
*从指定索引处获取子串的位置
*/
 public int indexOf(String str, int fromIndex) {
        return indexOf(value, 0, value.length,
                str.value, 0, str.value.length, fromIndex);
    }


/**
*
*/
static int indexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount,
            int fromIndex) {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (targetCount == 0) {
            return fromIndex;
        }

        char first = target[targetOffset];
        int max = sourceOffset + (sourceCount - targetCount);

        //逐个字符进行比较
        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            /* 查找第一个字符. */
            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++);

                if (j == end) {
                    /* Found whole string. */
                    return i - sourceOffset;
                }
            }
        }
        return -1;
    }


 public int indexOf(int ch) {
        return indexOf(ch, 0);
    }


 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) {
            // handle most cases here (ch is a BMP code point or a
            // negative value (invalid 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);
        }
    }