需求：一篇课文古诗进行背诵，点击提示一下提示背诵的下一句。

测试demo地址：https://pan.baidu.com/s/1IKrAUmhJ7jtxqne3NrkCTQ

tips：

 1.测试的话用intelliJ 或者eclipse 都可以。可以用控制台输入来替换语音输入。
 2.由于需求是语音输入，所以就把汉字转成了拼音，来弥补语音识别成文字的不准确（科大讯飞的语音识别已经挺准了，不需要可以把转拼音去掉，代码中使用拼音的换成汉字就行了）。 
 3.Android 可以把科大讯飞返回的结果转成字符串传入。（java的话暂时只实现了控制台输入汉字，有会的可以直接传）。
 4.考虑不是很全面欢迎提出意见。
 5.使用方法在文章的最下面。

主要思路
1.初始化内容，对内容进行处理，并拆分成一句一句。
2.当有背诵内容传入时对内容就行处理，原文中不存在的内容进行删除。
3.对处理完的 内容进行和原文匹配。
4.根据背诵的匹配结果获取应该提示的那一句。

上核心代码

public class RM {
    private static RM mInstance;
    private List<String> hanziList;

    public static RM getInstance() {
        if (mInstance == null) {
            mInstance = new RM();
        }
        return mInstance;
    }

    private String mContent;
    private int startIndex = 0;
    private List<String> pinYins;
    private List<TextBean> textBeanList;


    public void init(String original) {
        mContent = original;
        //去掉文章内容中\r和空格
        mContent = mContent.replaceAll("\\r", "");
        mContent = mContent.replaceAll(" ", "");
        pinYins = new ArrayList<>();
        hanziList = new ArrayList<>();
        for (int i = 0; i < mContent.length(); i++) {
            String text = String.valueOf(mContent.charAt(i));
            if (!text.equals("\n")) {
                String pinyin = PinYinUtils.getPinYin(text);
                pinYins.add(pinyin);
            }
        }
        textBeanList = new ArrayList<>();
        splitLine(mContent);
//        mContent = mContent.replaceAll("\\n", "");
    }

    public void recite(String text) {
        System.out.println("背诵内容 " + text);
        text = replaceSpecStr(text);
        List<String> rm = new ArrayList<>();
        List<String> ps = new ArrayList<>();
        for (int i = 0; i < text.length(); i++) {
            String word = String.valueOf(text.charAt(i));
            String pinyin = PinYinUtils.getPinYin(word);
            if (!pinYins.contains(pinyin)) {
                rm.add(word);
            } else {
                ps.add(pinyin);
            }
        }
        System.out.println("--------------" + ps.size());
        if (ps.size() > 0) {
            toMacth(ps);
//            toMacth(ps);
        }
    }

    private void toMacth(List<String> list) {
        boolean end = false;
        while (!end) {
            if (startIndex >= hanziList.size()) {
                System.out.println("已经匹配到最后");
                end = true;
                continue;
            }
            TextBean textBean = textBeanList.get(startIndex);
            //获取要匹配到内容
            List<String> macth = textBean.getPinYin();
            System.out.println("进行匹配对内容 " + macth);
            System.out.println("背诵对内容  " + list);
            List<Integer> indexs = new ArrayList<>();
            int errorNum = 0;
            for (String s : macth) {
                boolean has = false;
                for (int i = 0; i < list.size(); i++) {
                    if (s.equals(list.get(i)) && !indexs.contains(i)) {
                        indexs.add(i);
                        has = true;
                        break;
                    }
                }
                if (!has) {
                    indexs.add(-1);
                    errorNum++;
                }
            }
            textBean.toMacth(indexs);
            System.out.println(" 坐标匹配结果 " + indexs);
            if (indexs.size() == errorNum) {
                System.out.println(" 匹配结果全错 ");
                System.out.println(" 开始下一句匹配 ");
                //TODO 尝试进行后面匹配根据正确率判断是否移动匹配坐标
                end = true;
                continue;
            }

            List<Integer> rmValue = new ArrayList<>();
            for (int i = 0; i < indexs.size() - 1; i++) {
                int nowValue = indexs.get(i);
                int nextValue = indexs.get(i + 1);
                if (nowValue == -1 || nextValue == -1) {
                    continue;
                }
                if (indexs.get(i) >= indexs.get(i + 1)) {
                    rmValue.add(indexs.get(i));
                }
            }
            System.out.println("坐标不合理 移除需要移除" + rmValue);
            Iterator<Integer> iterator = indexs.iterator();
            while (iterator.hasNext()) {
                int value = iterator.next();
                if (rmValue.contains(value)) {
                    iterator.remove();
                }
            }
            System.out.println(" 移除不合理坐标后 " + indexs);
            System.out.println("对进行匹配对内容进行移除");
            List<String> strings = new ArrayList<>();
            int lastIndex = 0;
            for (int i = indexs.size() - 1; i > 0; i--) {
                if (indexs.get(i) != -1) {
                    lastIndex = indexs.get(i);
                    break;
                }
            }
            if (lastIndex >= list.size()) {

            } else {
                for (int i = lastIndex + 1; i < list.size(); i++) {
                    strings.add(list.get(i));
                }
            }

            list = strings;
            System.out.println("移除匹配后的内容 " + list);
            if (list.size() == 0) {
                System.out.println(textBean);
                end = true;
            }
            startIndex++;

        }


    }

    public String getRemind() {
        if (startIndex < textBeanList.size() - 1) {
            TextBean textBean = textBeanList.get(startIndex);
            if (textBean.whether()) {
                return textBean.sentence;
            }
            textBean = textBeanList.get(startIndex + 1);
            return textBean.sentence;
        } else {
            TextBean textBean = textBeanList.get(textBeanList.size() - 1);
            return textBean.sentence;
        }
    }


    /**
     * 获取当前内容标点符号最小位置
     *
     * @param text
     * @return
     */
    private int getIndex(String text) {
        List<Integer> indexs = new ArrayList<Integer>();
        if (text.contains(",")) {
            indexs.add(text.indexOf(","));
        }
        if (text.contains(".")) {
            indexs.add(text.indexOf("."));
        }
        if (text.contains("，")) {
            indexs.add(text.indexOf("，"));
        }
        if (text.contains(" ，")) {
            indexs.add(text.indexOf("，"));
        }
        if (text.contains("。")) {
            indexs.add(text.indexOf("。"));
        }
        if (text.contains("？")) {
            indexs.add(text.indexOf("？"));
        }
        if (text.contains("！")) {
            indexs.add(text.indexOf("！"));
        }
        if (text.contains("\n")) {
            int index = text.indexOf("\n");
            indexs.add(index);
        }
        if (text.contains("；")) {
            indexs.add(text.indexOf("；"));
        }
        if (text.contains(";")) {
            int index = text.indexOf(";");
        }
        if (indexs.size() == 0) {
            indexs.add(text.length());
        }

        return Collections.min(indexs);
    }

    /**
     * 正则替换所有特殊字符
     *
     * @param orgStr
     * @return
     */
    private String replaceSpecStr(String orgStr) {
        if (null != orgStr && !"".equals(orgStr.trim())) {
            String regEx = "[\\s~·`!！@#￥$%^……&*（()）\\-——\\-_=+【\\[\\]】｛{}｝\\|、\\\\；;。：:‘'“”\"，,《<。.》>、/？?\n\r]";
            Pattern p = Pattern.compile(regEx);
            Matcher m = p.matcher(orgStr);
            return m.replaceAll("");
        }
        return null;
    }

    /**
     * 分割成一句一句
     *
     * @param text
     */
    private void splitLine(String text) {
        int index = getIndex(text);
        String str = text.substring(0, index);
        str = replaceSpecStr(str);
        TextBean textBean = new TextBean();
        textBean.sentence = str;
        textBean.accuracy = 0;
        if (str != null && !str.equals("")) {
            hanziList.add(str);
            textBeanList.add(textBean);
        }
        if (index != text.length()) {
            text = text.substring(index + 1, text.length());

            splitLine(text);
        }

    }
}

对象代码

public class TextBean {
    String sentence;
    float accuracy = 0;
    int errorIndex = -1;
    String errorContent;
    boolean needRemind = true;

    public List<String> getPinYin() {
        List<String> pinyins = new ArrayList<String>();
        int start = errorIndex == -1 ? 0 : errorIndex;
        for (int i = start; i < sentence.length(); i++) {
            String str = String.valueOf(sentence.charAt(i));
            pinyins.add(PinYinUtils.getPinYin(str));
        }
        return pinyins;
    }

    public void toMacth(List<Integer> indexs) {
        int num = indexs.size();
        for (Integer index : indexs) {
            if (index == -1) {
                num--;
            }
        }
        accuracy = num / indexs.size();
    }

    public boolean whether() {
        if (accuracy < 0.4f) {
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "TextBean{" +
                "sentence='" + sentence + '\'' +
                ", accuracy=" + accuracy +
                ", errorIndex=" + errorIndex +
                ", errorContent='" + errorContent + '\'' +
                '}';
    }
}

使用方法
1.初始化

 RM.getInstance().init(mContent);

初始化要背诵的文章，课文或者古诗。

2.背诵
背诵一般是一句一句的背诵，每次接收到背诵的结果时调用。

 RM.getInstance().recite(text);

3.提示

String remind=RM.getInstance().getRemind();