int[] modelStrIndex;
    private void badCharInit(char[] modelStr) {
        modelStrIndex = new int[26];
        //-1表示該字符在匹配串中沒有出現(xiàn)過
        for (int i = 0 ; i < 26 ; i ++) {
            modelStrIndex[i] = -1;
        }
        for (int i = 0 ; i < modelStr.length ; i++) {
            //直接依次存入，出現(xiàn)相同的直接覆蓋，
            //保證保存的時候靠后出現(xiàn)的位置
            modelStrIndex[modelStr[i] - 'a'] = i;
        }
    }

/**
     * @param mainStr 主串
     * @param modelStr 模式串
     * @param start 模式串在主串中的起始位置
     * @return 模式串可滑動距離，如果為0則匹配上
     */
    private int badChar(char[] mainStr, char[] modelStr, int start) {
        //壞字符位置
        int badCharIndex = -1;
        char badChar = '\0';
        //開始從匹配串后往前進(jìn)行匹配
        for (int i = modelStr.length - 1 ; i >= 0 ; i --) {
            int mainStrIndex = start + i;
            //第一個出現(xiàn)不匹配的即為壞字符
            if (mainStr[mainStrIndex] != modelStr[i]) {
                badCharIndex = i;
                badChar = mainStr[mainStrIndex];
                break;
            }
        }
        if (-1 == badCharIndex) {
            //不存在壞字符,需匹配成功，要移動距離為0
            return 0;
        }
        //查看壞字符在匹配串中出現(xiàn)的位置
        if (modelStrIndex[badChar - 'a'] > -1) {
            //出現(xiàn)過
            return badCharIndex - modelStrIndex[badChar - 'a'];
        }
        return modelStr.length;
    }

//對應(yīng)位置的前綴后綴是否匹配
    boolean[] isMatch;
    public void goodSuffixInit(char[] modelStr) {
        isMatch = new boolean[modelStr.length / 2];
        StringBuilder prefixStr = new StringBuilder();
        List<Character> suffixChar = new ArrayList<>(modelStr.length / 2);
        for (int i = 0 ; i < modelStr.length / 2 ; i ++) {
            prefixStr.append(modelStr[i]);
            suffixChar.add(0, modelStr[modelStr.length - i - 1]);
            isMatch[i] = this.madeSuffix(suffixChar).equals(prefixStr.toString());
        }
    }
    /**
     * 組裝后綴數(shù)據(jù)
     * @param characters
     * @return
     */
    private String madeSuffix(List<Character> characters) {
        StringBuilder sb = new StringBuilder();
        for (Character ch : characters) {
            sb.append(ch);
        }
        return sb.toString();
    }

public int bmStrMatch(char[] mainStr, char[] modelStr) {
        //初始化壞字符和好后綴需要的數(shù)據(jù)
        this.badCharInit(modelStr);
        this.goodSuffixInit(modelStr);
    int start = 0;
        while (start + modelStr.length <= mainStr.length) {
            //壞字符計算的需要滑動的距離
            int badDistance = this.badChar(mainStr, modelStr, start);
            //好后綴計算的需要滑動的距離
            int goodSuffixDistance = this.goodSuffix(mainStr, modelStr, start);
            System.out.println("badDistance = " +badDistance  + "， goodSuffixDistance = " + goodSuffixDistance);
            //任意一個匹配成功即成功（可以計算了壞字符和好后綴之后分別判斷一下）
            //減少一次操作
            if (0 == badDistance || 0 == goodSuffixDistance) {
                System.out.println("匹配到的位置 ：" + start);
                return start;
            }
            start += Math.max(badDistance, goodSuffixDistance);
            System.out.println("滑動至：" + start);
        }
        return -1;
    }

public static void main(String[] args) {
        BoyerMoore moore = new BoyerMoore();
        char[] mainStr = new char[]{'a','b', 'c', 'a', 'g', 'f', 'a', 'c', 'j', 'k', 'a', 'c', 'k', 'e', 'a', 'c'};
        char[] modelStr = new char[]{'a', 'c', 'k', 'e', 'a', 'c'};
        System.out.println(moore.bmStrMatch(mainStr, modelStr));
    }