模糊算法

项目实例下载:https://gitee.com/Keith404/fuzzy_algorithm/tree/master/

2018/11/7    16:55 修改

import java.util.ArrayList;
import java.util.List;

public class FuzzyMatching {

    //参数
    private int substrCrossDomain = 2; //子串允许的跨界下标值
    private int substrElimination = 2; //子串允许的消除个数值
    private int mainstrCrossDomain = 100; //主串允许的跨界下标值
    private boolean reportOpen = true; //是否显示汇报结果

    //变量
    private String mainString = ""; //主串字符串
    private String subString = ""; //子串字符串
    private int substrSubscript = 0; //子串下标
    private int subscriptMovementCount = 0; //子串移动下标次数
    private int currentEliminationNumber = 0; //存储消除子串字符的数值
    private int mainstrPreviousSubscript = 0; //主串的前一次下标值
    private boolean effectiveness; //返回值
    private List matchingItem; //符合条件的子串字符集
    private List report; //汇报内容
    private List result; //主串出现位置结果集

    //首字符出现的位置
    private int fistCharShow = -1;

    //是否执行过getResult
    private boolean readGetResult = false;

    //构造方法
    public FuzzyMatching() {
        report = new ArrayList();
        matchingItem = new ArrayList();
        result = new ArrayList();
    }

    public FuzzyMatching(String mainString, String subString) {
        report = new ArrayList();
        matchingItem = new ArrayList();
        result = new ArrayList();
        this.mainString = mainString;
        this.subString = subString;

    }

    //

    //设置主串和子串方法
    public void setMainString(String mainString) {
        this.mainString = mainString;
    }

    public void setSubString(String subString) {
        this.subString = subString;
    }

    //获取主串和子串
    public String getMainString() {
        return this.mainString;
    }

    public String getSubString() {
        return this.subString;
    }

    //设置参数值
    public void setSubstrCrossDomain(int value) {
        this.substrCrossDomain = value;
    }

    public void setSubstrElimination(int value) {
        this.substrElimination = value;
    }

    public void setMainstrCrossDomain(int value) {
        this.mainstrCrossDomain = value;
    }

    public void setReportOpen(boolean value) {
        this.reportOpen = value;
    }

    //返回主串分别出现的数据结果
    public List getResult() {
        if (readGetResult) {
            return this.result;
        } else {
            System.out.println("还没执行getEffectiveness方法");
            return this.result; //有待完善
        }

    }

    //返回匹配到的子串字符
    public List getMatchingItem() {
        if (readGetResult) {
            return this.matchingItem;
        } else {
            System.out.println("还没执行getEffectiveness方法");
            return this.matchingItem; //有待完善
        }
    }


    public Boolean getEffectiveness() {

        for (int i = 0; i < mainString.length(); i++) { if (mainString.charAt(i) == subString.charAt(0)) { if ((mainString.length()-i) > substrElimination){
                    fistCharShow = i;
                    break;
                }
            }
        }

        if (fistCharShow != -1){

        }else {
            substrSubscript++;
            fistCharShow = 0;
        }

        int mainStringSubscript = 0;
        mainStringSubscript = fistCharShow;
        while(mainStringSubscript<mainString.length()){

            subscriptMovementCount = 0;
            for (int j = substrSubscript; j < subString.length(); j++) {
                if (subscriptMovementCount < substrCrossDomain) {
                    if (mainString.charAt(mainStringSubscript) == subString.charAt(j)) {
                        if (mainStringSubscript - mainstrPreviousSubscript < mainstrCrossDomain) { //判断主串下标移动的范围值，如果是第一次匹配，则无穷
                            substrSubscript = j + 1;//将子串下标设置为当前匹配到的下标，并将子串下标移一位
                            matchingItem.add(subString.charAt(j));
                            result.add(mainStringSubscript);
                        } else {
                            report.add("超出主串允许的跨界幅度:" + mainString.charAt(mainStringSubscript));

                        }
                        mainstrPreviousSubscript = mainStringSubscript;
                        break;
                    }

                } else {
                    break;
                }
                subscriptMovementCount++;
                if (j==subString.length()){
                    mainStringSubscript = fistCharShow;
                }


            }

            mainStringSubscript ++;
        }

        for (int i = fistCharShow; i < mainString.length(); i++) { } currentEliminationNumber = subString.length() - matchingItem.size(); //汇报信息处理 String strs = "子串符合主串匹配的字符集为:"; if (currentEliminationNumber > substrElimination) {
            report.add("消除的子串个数超过预设值，所以结果无效");
            effectiveness = false;
        } else {
            report.add("消除的子串个数在预设值内，所以结果有效");
            effectiveness = true;
        }


        for (int i = 0; i < matchingItem.size(); i++) {
            strs += matchingItem.get(i).toString();
        }
        report.add(strs);
        strs = "在主串分别出现的位置为(以0作为起始值)：";
        for (int i = 0; i < result.size(); i++) {
            strs += result.get(i).toString() + ",";
        }
        report.add(strs);

        //汇报
        if (reportOpen) {
            for (int i = 0; i < report.size(); i++) {
                System.out.println(report.get(i));
            }
        }
        this.readGetResult = true;
        return effectiveness;
    }


}