JAVA一段文字和原文对比，在原文中标出错误

因业务需求需要做一个文字对比的功能，在原文中标出错误的地方。网上找了好久，多就是通过分词挑出两个内容中的不同。于是自己写了一个简单工具类，新手代码不是很规则，不懂算法就自己的想法写的，各位大神勿喷，多多指导。

效果图如下

image.png

下面上代码：

public class ResultUtils {

    private static List<WordBean> origlist;
    private static List<String> tarList;
    private static List<WordBean> errorList;
    private static List<String> pinOrigList;

    /**
     * 获取背诵，原文中那些字背错了
     *
     * @param original
     *            原文
     * @param reciteText
     *            背诵的内容
     * @return
     */
    public static List<WordBean> getError(String original, String reciteText) {
        init();
        handleText(original, reciteText);
        return dispose();
    }

    /**
     * 初始化某些集合
     */
    private static void init() {
        origlist = new ArrayList<WordBean>();
        tarList = new ArrayList<String>();
        errorList = new ArrayList<WordBean>();
        pinOrigList = new ArrayList<String>();
    }

    /**
     * 字符串处理
     *
     * @param original
     * @param reciteText
     */
    private static void handleText(String original, String target) {
        // 去除原文和背诵内容中的特殊字符（注：先去掉标点之后再考虑标点问题）
        // original = replaceSpecStr(original);
        target = replaceSpecStr(target);
        // 去除 背诵内容中的数字
//      target = target.replaceAll("\\d+", "");
        // 原文进行单字拆分放入集合
        for (int i = 0; i < original.length(); i++) {
            // 单个文字拆分
            String str = replaceSpecStr(String.valueOf(original.charAt(i)));
            // 对非空文字进行保存
            if (str != null && !"".equals(str)) {
                // 生成对象并保存
                WordBean wBean = new WordBean();
                wBean.setOraIndex(i);
                wBean.setWord(str);
                origlist.add(wBean);
                pinOrigList.add(str);
            }
        }
        // 对背诵内容进行筛选，把原文中存在的字符挑出来
        for (int i = 0; i < target.length(); i++) {
            String str = String.valueOf(target.charAt(i));
            // 转成拼音进行判断
            // 原文集合中存在的文字加入到集合
            if (pinOrigList.contains(str)) {
                tarList.add(str);
            }
        }

        // 原文和背诵内容进行对比，确定原文中文字在背诵内容中的位置
        for (WordBean bean : origlist) {
            for (int i = 0; i < tarList.size(); i++) {
                // 文字相同，确定位置
                if (bean.getWord().equals(tarList.get(i))) {
                    bean.addLocation(i);
                }
            }
        }
    }

    /**
     * 对两个集合进行处理
     */
    private static List<WordBean> dispose() {
        // 挑出对应位置为空的对象
        for (WordBean wordBean : origlist) {
            if (wordBean.getTarIndexs() == null) {
                errorList.add(wordBean);
            }
        }
        // 移除位置为空的对象
        origlist.removeAll(errorList);
        // 多个对应位置的对象集合
        List<WordBean> list = getRepetitionWord();
        // 移除多个对象的
        origlist.removeAll(list);
        // 文字重复的对象集合
        List<WordBean> sriglist = getSingleRepetition(origlist);
        // 移除单个重复对象
        origlist.removeAll(sriglist);
        // 处理剩余单个集合
        disposeOne(origlist);
        for (WordBean wordBean : list) {
            origlist.add(wordBean);
            sort(origlist);
            disposeMore(wordBean, origlist);
        }

        for (WordBean wordBean : sriglist) {
            origlist.add(wordBean);
            sort(origlist);
            disposeMore(wordBean, origlist);
        }
        origlist.addAll(errorList);
        sort(origlist);
        return origlist;
    }

    /**
     * 挑出原文中汉字中，对应位置较多的文字 因为汉字重复所以会产生多个位置
     *
     * @return
     */
    private static List<WordBean> getRepetitionWord() {
        List<WordBean> beans = new ArrayList<WordBean>();
        for (WordBean bean : origlist) {
            if (bean.getTarIndexs() != null && bean.getTarIndexs().size() > 1) {
                beans.add(bean);
            }
        }
        return beans;
    }

    /**
     * 挑出原文中重复的文字
     *
     * @param list
     * @return
     */
    private static List<WordBean> getSingleRepetition(List<WordBean> list) {
        List<WordBean> beans = new ArrayList<WordBean>();
        for (WordBean bean : list) {
            for (WordBean wBean : list) {
                if (bean != wBean && !beans.contains(bean)
                        && bean.getWord().equals(wBean.getWord())) {
                    beans.add(bean);
                }
            }
        }
        return beans;
    }

    /**
     * 对集合中有一个对应位置的文字进行判断处理
     *
     * @param copy
     */
    private static void disposeOne(List<WordBean> copy) {

        for (int i = 0; i <= copy.size() - 1; i++) {
            WordBean bean = copy.get(i);
            if (bean.getTarIndexs() == null) {
                // 当前对象的对应位置为空，结束本层循环
                continue;
            }
            // 获取下一个对象
            WordBean nextBean = getNext(bean, copy);
            if (nextBean == null) {
                continue;
            }
            // 位置对应关系，如果当前对象对应位置大于下一个对象的对应位置，当前对象位置不合理置空
            if (bean.getTarIndexs().get(0) > nextBean.getTarIndexs().get(0)) {
                bean.setTarIndexs(null);
                disposeOne(copy);
            }
        }
    }

    /**
     * 对存在多个对应位置的对象进行处理
     *
     * @param bean
     * @param list
     */
    private static void disposeMore(WordBean bean, List<WordBean> list) {
        // System.err.println(bean.toString());
        int position = list.indexOf(bean);
        // 如果当前对象是对一个对象
        // 判断标记，是否存在合适位置
        boolean isEnd = false;
        if (position == 0) {
            // 获取下一个对象
            WordBean next = getNext(bean, list);
            // 对位置进行遍历判断
            for (Integer in : bean.getTarIndexs()) {
                // 位置关系是当前对应位置小于下一个对象的对应位置
                if (next != null && in < next.getTarIndexs().get(0)) {
                    // 满足关系对对象进行保存，结束循环
                    List<Integer> integers = new ArrayList<Integer>();
                    integers.add(in);
                    bean.setTarIndexs(integers);
                    isEnd = true;
                    break;
                }
            }
        } else if (position == list.size()) {
            // 如果当前位置是最后一个
            WordBean lastBean = getLast(bean, list);
            // 对位置进行遍历判断
            for (Integer in : bean.getTarIndexs()) {
                // 位置关系是当前对应位置大于上一个对象的对应位置
                if (lastBean != null && in > lastBean.getTarIndexs().get(0)) {
                    // 满足关系对对象进行保存，结束循环
                    List<Integer> integers = new ArrayList<Integer>();
                    integers.add(in);
                    bean.setTarIndexs(integers);
                    isEnd = true;
                    break;
                }
            }
        } else {
            // 当前位置是中间位置
            WordBean lastBean = getLast(bean, list);
            WordBean nextBean = getNext(bean, list);
            // 遍历对应位置
            for (Integer in : bean.getTarIndexs()) {

                // 位置对应关系，大于上一个，小于下一个
                if (lastBean != null && nextBean != null
                        && in > lastBean.getTarIndexs().get(0)
                        && in < nextBean.getTarIndexs().get(0)) {
                    // 满足关系对对象进行保存，结束循环
                    List<Integer> integers = new ArrayList<Integer>();
                    integers.add(in);
                    bean.setTarIndexs(integers);
                    isEnd = true;
                    break;
                }
            }
        }

        // 没有合适的位置对应。置空
        if (!isEnd) {
            bean.setTarIndexs(null);
        }

    }

    /**
     * 获取当前文字对象，上一个有对应位置的对象
     *
     * @param bean
     * @param list
     * @return
     */
    private static WordBean getLast(WordBean bean, List<WordBean> list) {
        int index = list.indexOf(bean);
        WordBean rsultBean = null;
        for (int i = index - 1; i >= 0; i--) {
            if (list.get(i).getTarIndexs() != null) {
                rsultBean = list.get(i);
                break;
            }
        }
        return rsultBean;
    }

    /**
     * 获取当前文字对象，下一个有对应位置的对象
     *
     * @param wordBean
     * @param wBeans
     * @return
     */
    private static WordBean getNext(WordBean wordBean, List<WordBean> wBeans) {
        WordBean bean = null;
        int dex = wBeans.indexOf(wordBean);
        for (int i = dex + 1; i < wBeans.size(); i++) {
            if (wBeans.get(i).getTarIndexs() != null) {
                bean = wBeans.get(i);
                break;
            }
        }
        return bean;
    }

    /**
     * 集合排序，根据在原文中的位置进行排序
     *
     * @param list
     */
    private static void sort(List<WordBean> list) {
        Collections.sort(list, new Comparator<WordBean>() {
            public int compare(WordBean arg0, WordBean arg1) {
                if (arg0.getOraIndex() < arg1.getOraIndex()) {
                    return -1;
                } else if (arg0.getOraIndex() > arg1.getOraIndex()) {
                    return 1;
                }
                return 0;
            }
        });
    }

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

bean对象代码

public class WordBean implements Serializable{

private String word;
private List<Integer> tarIndexs;
private int oraIndex;

public String getWord() {
    return word;
}

public void setWord(String word) {
    this.word = word;
}

public List<Integer> getTarIndexs() {
    return tarIndexs;
}

public void setTarIndexs(List<Integer> tarIndexs) {
    this.tarIndexs = tarIndexs;
}

public void addLocation(int index) {
    if (tarIndexs == null)
        tarIndexs = new ArrayList<Integer>();
    tarIndexs.add(index);
}

public void removeLocation(int index) {
    if (tarIndexs == null) {
        return;
    }
    tarIndexs.remove(tarIndexs.indexOf(index));
}

public int getOraIndex() {
    return oraIndex;
}

public void setOraIndex(int oraIndex) {
    this.oraIndex = oraIndex;
}


@Override
public String toString() {
    return "WordBean{" +
            "word='" + word + '\'' +
            ", tarIndexs=" + tarIndexs +
            ", oraIndex=" + oraIndex +
            '}';
}

}

JAVA一段文字和原文对比 ，在原文中标出错误

推荐阅读更多精彩内容

JAVA一段文字和原文对比，在原文中标出错误