public static int strStr(String haystack, String needle) {
    // 字符串转为 char数组
    char[] chars = haystack.toCharArray();
    char[] chars1 = needle.toCharArray();
    // 遍历字符串 haystack
    for (int i = 0; i < chars.length; i++) {
        // n表示第二层for循环的数组下标， m表示第一层for循环的数组下标
        int n = 0;
        int m = i;
        // 遍历 needle对应的 char数组，判断 chars[m] == chars1[n]
        while(m < chars.length && n < chars1.length && chars[m] == chars1[n]){
            m++;
            n++;
        }
        // 判断遍历的第二个字符串 needle的数组是否遍历完成
        // 只有 needle包含在 haystack中，才能使得 n == chars.length
        if (n == chars1.length && chars[m - 1] == chars1[n - 1]){
            return i;
        }
    }
    return -1;
}
复制代码

int[] next = {0,1,0,1,2,0}
复制代码

public static int[] getNext(String s,int[] next){
    int j = 0;
    // 初始化下标 0
    next[0] = 0;
    for (int i = 1; i < s.length(); i++) {
        while(j > 0 && s.charAt(j) != s.charAt(i)){
            j = next[j - 1];
        }
        if (s.charAt(j) == s.charAt(i)){
            j++;
        }
        next[i] = j;
    }
    return next;
}
复制代码

public static int strStr2(String haystack, String needle) {
        // 如果 needle为 “” 则返回0
        if (needle.length() == 0){
            return 0;
        }
        // 如果 needle的长度大于 haystack则返回 -1
        if (needle.length() > haystack.length()){
            return -1;
        }
        // 生成 next数组
        int[] next = new int[needle.length()];
        getNext(needle,next);
        // 标记指针在 needle回退后的位置
        int j = 0;
        for (int i = 0; i < haystack.length(); i++) {
            // 判断当前位置
            while(j > 0  && haystack.charAt(i) != needle.charAt(j)){
                j = next[j - 1];
            }
            if (haystack.charAt(i) == needle.charAt(j)){
                j++;
            }
            if (j == needle.length()){
                return i - j + 1;
            }
        }
        return -1;
    }
    public static int[] getNext(String s,int[] next){
        int j = 0;
        // 初始化下标 0
        next[0] = 0;
        for (int i = 1; i < s.length(); i++) {
            while(j > 0 && s.charAt(j) != s.charAt(i)){
                j = next[j - 1];
            }
            if (s.charAt(j) == s.charAt(i)){
                j++;
            }
            next[i] = j;
        }
        return next;
    }
复制代码

String haystack = "mississippi", needle = "issip";
int i1 = haystack.indexOf(needle);
复制代码

// source:       当前字符串元素
// sourceOffset: 偏移量
// sourceCount： 当前字符串长度
// target：      目标字符串
// targetOffset：目标字符串偏移量
// targetCount： 目标字符串长度
// 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;
    }
    // 如果目标字符串的长度为 0则直接返回 索引位置 （我们这里因为之前方法重载 fromIndex为 0 所以返回 0）
    if (targetCount == 0) {
        return fromIndex;
    }
    // 获取目标 首字符
    char first = target[targetOffset];
    // 我们这里就是 源字符串长度 - 目标字符串长度， sourceOffset == 0
    int max = sourceOffset + (sourceCount - targetCount);
    // 循环，i == 0
    // 加入循环到了 max的索引位置还没有找到和 目标字符串首字符相等的元素，则源字符串中肯定不包含目标字符串
    for (int i = sourceOffset + fromIndex; i <= max; i++) {
        // 搜索首字符所在位置
        if (source[i] != first) {
            while (++i <= max && source[i] != first);
        }
        // 找到了首字符，判断其余字符位置是否相等
        if (i <= max) {
            int j = i + 1;
            // 根据目标字符串的长度截取源字符串从下标 i开始相同长度的字符串
            int end = j + targetCount - 1;
            // 遍历判断
            for (int k = targetOffset + 1; j < end && source[j]
                    == target[k]; j++, k++);
            // 如果到最后一个元素都相同，则代表源字符串内包含目标字符串
            if (j == end) {
                // 这里就直接返回了 i 因为源字符串偏移量为 0
                return i - sourceOffset;
            }
        }
    }
    return -1;
}
复制代码

public static int strStr(String haystack, String needle) {
    // 如果 needle为 “” 则返回0
    if (needle.length() == 0){
        return 0;
    }
    // 如果 needle的长度大于 haystack则返回 -1
    if (needle.length() > haystack.length()){
        return -1;
    }
    int max = haystack.length() - needle.length();
    char first = needle.charAt(0);
    for (int i = 0; i <= max; i++) {
        if (haystack.charAt(i) != first){
            while(++i <= max && haystack.charAt(i) != first);
        }
        if (i <= max) {
            int j = i + 1;
            int end = j + needle.length() - 1;
            for (int k = 1; j < end && haystack.charAt(j)
                    == needle.charAt(k); j++, k++);
            if (j == end) {
                return i ;
            }
        }
    }
    return -1;
}
复制代码