浅析JDK中的contains底层源码

package com.item.demoMin;

public class ContainsDemo {
    private final char value[]={'d','q'};
    /**
     * contains方法
     * CharSequence 类似于String String是只读，而他，可写
     * indexOf  将形参s转化为String类型 然后判断形参s是包含在N.indexOf() 里面；
     * @param s 形参
     * @return s.toString() 若包含于N.contains中的N，则返回true，否则返回false
     */
    public boolean contains(CharSequence s){
        return indexOf(s.toString())>-1;
    }

    /**
     * indexOf(str,0) 从下标0，也就是第一个字符开始查询，直到找到str的值 然后return 相对应的下标值，如果没有则返回-1
     * @param str 查询的目标值
     * @return
     */
    public int indexOf(String str) {
        return indexOf(str, 0);
    }

    /**
     *
     * @param str 查询的目标值
     * @param fromIndex
     * @return
     */
    public int indexOf(String str, int fromIndex) {
        return indexOf(value, 0, value.length,
                str.value, 0, str.value.length, fromIndex);
    }


    /**
     * 目标字符串与源字符串的字符进行逐一匹配
     * 若第一个字符匹配成功，则进行余下的匹配
     * 若余下的匹配不成功，则从一开始目标字符串的第一个字符与源字符串匹配时的下标的下一位继续进行匹配
     * @param source  values
     * @param sourceOffset 0
     * @param sourceCount values.length
     * @param target str.value
     * @param targetOffset 0
     * @param targetCount str.values.length
     * @param fromIndex fromIndex 匹配的起始下标
     * @return
     */
    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;
    }

    public static void main(String[] args) {
        String count="";
        count.contains("");
    }


}