【无标题】

最新推荐文章于 2022-09-13 14:03:48 发布

老马识途2.0

最新推荐文章于 2022-09-13 14:03:48 发布

阅读量1k

点赞数

分类专栏：笔记 java 文章标签： java

本文链接：https://blog.csdn.net/csdnliuxin123524/article/details/124083154

版权

java 同时被 2 个专栏收录

102 篇文章 16 订阅

订阅专栏

笔记

10 篇文章 0 订阅

订阅专栏

1,创建普通maven工程

在这里插入图片描述

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kjgs</groupId>
    <artifactId>language</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.11</version>
        </dependency>
    </dependencies>
</project>

可行性分析

package 入口;

import com.alibaba.fastjson.JSON;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import 实体.Dongzuo;
import 实体.成分;
import 工具.Util;
import 工具.常量;
import 工具.父子节点排序;
import 执行.处理方法;

import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;

public class 可行性分析 {
    static Scanner scanner = new Scanner(System.in);
    public static CopyOnWriteArrayList<成分> chengfenList = new CopyOnWriteArrayList<成分>();
    public static Stack<Dongzuo> 动作集合 = new Stack<>();
    public static String 上一步结果 = "";
    public static String 集合数据 = "";
    public static Set<String> methodnames = new HashSet<>();
    public static CopyOnWriteArrayList<String> 方法集合 = null;
    public static String[] chengfenFilenames = {"D:/my/kjgs/chengfen17.txt", "D:/my/kjgs/chengfen18.txt"};
    public static String dongzuoFilename = "D:/my/kjgs/dongzuo.txt";

    public static void main(String[] args) {
        init();
        while (true) {
            System.out.println("请输入:");
            String sen = scanner.nextLine();
            Util.增加成分(new 成分().setRenwu(常量.当前输入句子).setShuxing(sen).setGuanxi(常量.是));
            int flag = 0;//0 成功，1 逻辑执行意向，2 逻辑是空
            if (sen.trim().equals(常量.待解释词是空)) {
                方法集合 = Util.依次找方法(methodnames, sen);
                if (CollectionUtils.isEmpty(方法集合)) {
                    flag = 2;
                } else {
                    Util.增加成分(new 成分().setRenwu(常量.当前句子).setShuxing(sen).setGuanxi(常量.是).setExplained(Util.获取最新成分属性(常量.待解释词)));
                    try {
                        Util.执行方法逻辑(方法集合);
                    } catch (Exception e) {
                        System.out.println(Util.获取最新成分属性(常量.内部方法的错误信息));
                        e.printStackTrace();
                    }
                    continue;
                }
            } else {
                try {
                    String 预处理逻辑 = Util.获取成分人物(常量.预处理逻辑, 常量.是);
                    List<String> list = JSON.parseArray(预处理逻辑, String.class);
                    父子节点排序.父子节点排序(list, 常量.前面);
                    Map<String, List<String>> 预处理逻辑集合 = Util.获取预处理逻辑(list);
                    List<String> 预处理结果list = Util.获取预处理逻辑并依次执行(预处理逻辑集合, false);
                    预处理结果list = Util.筛选预处理结果中的有逻辑处理的(预处理结果list);
                    if (Util.获取等于内部方法的句子(sen) != null) 预处理结果list.add(sen);
                    Util.增加成分(new 成分().setRenwu(常量.预处理结果).setShuxing(JSON.toJSONString(预处理结果list)).setGuanxi(常量.是));
                } catch (Exception e) {
                    System.out.println((Util.获取最新成分属性(常量.预处理结果)));
                    e.printStackTrace();
                }
                String 预处理结果 = Util.获取最新成分属性(常量.预处理结果);
                if (StringUtils.isEmpty(预处理结果) || "[]".equals(预处理结果)) {
                    flag = 2;
                } else {
                    if (!常量.空.equals(Util.获取最新成分属性(常量.待解释词)) && StringUtils.isNotEmpty(Util.获取最新成分属性(常量.待解释词))) {
                        Util.增加成分(new 成分().setRenwu(常量.当前句子).setShuxing(sen).setGuanxi(常量.是).setExplained(Util.获取最新成分属性(常量.待解释词)));
                    }
                    Util.增加成分(new 成分().setRenwu("------------------start----------------").setShuxing("用历史逻辑处理").setGuanxi(常量.是));
                    try {
                        if(Util.执行思维集合(预处理结果,true)){
                            flag=0;
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    Util.增加成分(new 成分().setRenwu("--------------------end------------ -").setShuxing("用历史逻辑处理").setGuanxi(常量.是));
                }
            }
            if (flag == 1) {
                System.out.println((Util.获取最新成分属性(常量.内部方法的错误信息)));
            } else if (flag == 2) {
                Util.增加成分(new 成分().setRenwu(常量.组装词1).setShuxing(sen).setGuanxi(常量.是));
                Util.增加成分(new 成分().setRenwu(常量.组装词2).setShuxing(常量.是什么).setGuanxi(常量.是));
                try {
                    Util.反射执行指定方法(常量.组装句子);
                    Util.增加成分(new 成分().setRenwu(常量.疑问句子).setShuxing(Util.获取最新成分属性(常量.上一步结果)).setGuanxi(常量.是));
                } catch (Exception e) {
                    System.out.println((Util.获取最新成分属性(常量.内部方法的错误信息)));
                    e.printStackTrace();
                }
                System.out.println((Util.获取最新成分属性(常量.上一步结果)));
            }

        }
}

    public static void init() {
        Method[] declaredmethods = 处理方法.class.getDeclaredMethods();
        for (Method m : declaredmethods) {
            methodnames.add(m.getName());
        }
        try {
            for (String filename : 可行性分析.chengfenFilenames) {
                CopyOnWriteArrayList<成分> collect = Util.readFileByLine(filename)
                        .stream().filter(m -> StringUtils.isNotEmpty(m))
                        .map(m -> JSON.parseObject(m, 成分.class))
                        .collect(Collectors.toCollection(CopyOnWriteArrayList::new));
                if (CollectionUtils.isNotEmpty(collect)) {
                    chengfenList.addAll(collect);
                }
            }
            动作集合 = Util.readFileByLine(可行性分析.dongzuoFilename).stream()
                    .filter(m -> StringUtils.isNotEmpty(m)).map(m -> JSON.parseObject(m, Dongzuo.class))
                    .collect(Collectors.toCollection(Stack::new));
        } catch (Exception e) {
            e.printStackTrace();
        }
        Util.增加成分(new 成分().setRenwu(常量.上一次判断结果).setShuxing(常量.TRUE).setGuanxi(常量.是));
        Util.增加成分(new 成分().setRenwu(常量.待解释词).setShuxing(常量.空).setGuanxi(常量.是));
    }
}

Dongzuo

package 实体;

public class Dongzuo {
    public String sen;
    public String methodName;
    public Integer paramNum;
    public String param1;
    public String param2;

    public String getSen() {
        return sen;
    }

    public Dongzuo setSen(String sen) {
        this.sen = sen;return this;
    }

    public String getMethodName() {
        return methodName;
    }

    public Dongzuo setMethodName(String methodName) {
        this.methodName = methodName;return this;
    }

    public Integer getParamNum() {
        return paramNum;
    }

    public Dongzuo setParamNum(Integer paramNum) {
        this.paramNum = paramNum;return this;
    }

    public String getParam1() {
        return param1;
    }

    public Dongzuo setParam1(String param1) {
        this.param1 = param1;return this;
    }

    public String getParam2() {
        return param2;
    }

    public Dongzuo setParam2(String param2) {
        this.param2 = param2;return this;
    }
}

成分

package 实体;

import java.lang.reflect.Field;
import java.util.Objects;

public class 成分 {
    public String shuxing;
    public String renwu;
    public String guanxi;
    public Integer sxindex=1;
    public Integer rwindex=1;
    public String juzi;
    public String fujuzi;
    public String wenju;
    public String explained;

    public Object getValue(Object object,String fieldName){
        try{
            Field field=object.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            try {
                return field.get(object);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }catch (NoSuchFieldException e){

        }
        return null;
    }
    public <T> void setValue(T t,String fieldName,Object value){
        Class<T> tClass=(Class<T>)t.getClass();
        Field declaredField = null;
        try {
            declaredField = tClass.getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        declaredField.setAccessible(true);
        try {
            declaredField.set(t,value);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    public String getShuxing() {
        return shuxing;
    }

    public 成分 setShuxing(String shuxing) {
        this.shuxing = shuxing;return this;
    }

    public String getRenwu() {
        return renwu;
    }

    public 成分 setRenwu(String renwu) {
        this.renwu = renwu;return this;
    }

    public String getGuanxi() {
        return guanxi;
    }

    public 成分 setGuanxi(String guanxi) {
        this.guanxi = guanxi;return this;
    }

    public Integer getSxindex() {
        return sxindex;
    }

    public 成分 setSxindex(Integer sxindex) {
        this.sxindex = sxindex;return this;
    }

    public Integer getRwindex() {
        return rwindex;
    }

    public 成分 setRwindex(Integer rwindex) {
        this.rwindex = rwindex;return this;
    }

    public String getJuzi() {
        return juzi;
    }

    public 成分 setJuzi(String juzi) {
        this.juzi = juzi;return this;
    }

    public String getFujuzi() {
        return fujuzi;
    }

    public 成分 setFujuzi(String fujuzi) {
        this.fujuzi = fujuzi;return this;
    }

    public String getWenju() {
        return wenju;
    }

    public 成分 setWenju(String wenju) {
        this.wenju = wenju;return this;
    }

    public String getExplained() {
        return explained;
    }

    public 成分 setExplained(String explained) {
        this.explained = explained;return this;
    }

    public boolean equals(成分 obj) {
       if(obj.renwu.equals(this.renwu) &&
       obj.shuxing.equals(this.shuxing)
       && obj.guanxi.equals(this.guanxi)){
           return true;
       }
       return false;
    }

    @Override
    public int hashCode() {
        return Objects.hash(shuxing, renwu, guanxi, sxindex, rwindex, juzi, fujuzi, wenju, explained);
    }
}

Util

package 工具;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONException;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import 入口.可行性分析;
import 实体.成分;
import 执行.处理方法;

import java.io.*;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Util {
    static 处理方法 obj = new 处理方法();
    static Class clz=obj.getClass();
    static String 当前句子方法集合="";
    public static List 获取句子中包含的方法(String sen){
        return Util.依次找方法(可行性分析.methodnames,sen);
    }
//    public static boolean 判断两个词是否在关系链中(String 人物,String 属性,String 关系){
//        递归获取关系属性();
//    }
    public static List<String> 根据元素分类过滤集合(List<String> 集合数据,String 属性){
        return 集合数据.stream().filter(m-> CollectionUtils.isNotEmpty(JSON.parseArray(获取成分关系(m,属性),String.class))).collect(Collectors.toList());
    }
    public static List<String> 递归获取关系属性(String 属性,String 关系){
        List<String> list = JSON.parseArray(获取成分人物(属性,关系),String.class);
        if(CollectionUtils.isNotEmpty(list)){
            递归获取关系属性(关系,new ArrayList(){{
                addAll(list);
            }},list);
        }
        return list;
    }

    public static void 递归获取关系属性(String 关系, List<String> 集合数据, List<String> 全部集合数据) {
        for(String str:集合数据){
            List<String> list = JSON.parseArray(获取成分人物(str,关系),String.class);
            if(CollectionUtils.isNotEmpty(list)){
                全部集合数据.addAll(list);
                递归获取关系属性(关系,list,全部集合数据);
            }
        }
    }
    public static String 替换句子中的相似词(String sen){
        sen = sen.replace("二","2");
        sen = sen.replace("一","1");
        String fianlSen = sen;
        return JSON.toJSONString(new ArrayList(){{
            add(fianlSen);
        }});
    }
    public static boolean 历史逻辑处理前的判断(boolean 是否添加当前句子)throws Exception{
        获取判断逻辑并依次执行(是否添加当前句子);
        return true;
    }
    public static String 获取等于内部方法的句子(String sen){
        if(可行性分析.methodnames.contains(sen)){
            return sen;
        }
        return null;
    }
    public static List<String> 筛选预处理结果中的有逻辑处理的(List<String> 预处理结果list){
        return 预处理结果list.stream().filter(m->{
            String 逻辑集合 = 获取待解释词(m);
            if(StringUtils.isNotEmpty(逻辑集合)){
                if(CollectionUtils.isNotEmpty(JSON.parseArray(逻辑集合,String.class))){
                    return true;
                }
            }
            return false;
        }).collect(Collectors.toList());
    }
    public static void 获取判断逻辑并依次执行(boolean 是否添加当前句子) throws  Exception{
        String 预处理逻辑=获取成分人物(常量.判断逻辑, 常量.是);
        List<String> list =JSON.parseArray(预处理逻辑,String.class);
        Map<String,List<String>> 预处理逻辑集合 = 获取预处理逻辑(list);
        for(Map.Entry entry:预处理逻辑集合.entrySet()){
            执行思维集合(JSON.toJSONString(entry.getValue()),是否添加当前句子);
        }
    }
    public static List<String> 获取预处理逻辑并依次执行(Map<String,List<String>> 预处理逻辑集合,boolean 是否添加当前句子)throws Exception{
        //对预处理结果排序
        List<String> 预处理结果list =new ArrayList<>();
        for(Map.Entry entry:预处理逻辑集合.entrySet()){
            //有处理逻辑了，就不往下找了
            if(CollectionUtils.isNotEmpty(预处理结果list)){
                break;
            }
            执行思维集合(JSON.toJSONString(entry.getValue()),是否添加当前句子);
            String 上一步结果 = Util.获取最新成分属性(常量.上一步结果);
            List<String> 上一步结果list =JSON.parseArray(如果不能转list就加入(上一步结果),String.class);
            if(CollectionUtils.isNotEmpty(上一步结果list)){
                预处理结果list.addAll(上一步结果list);
            }
        }
        预处理结果list = 预处理结果list.stream().distinct().collect(Collectors.toList());
        return 预处理结果list;
    }
    public static String 如果不能转list就加入(String str){
        try{
            List<Object> list = JSON.parseArray(str, Object.class);
            return JSON.toJSONString(list);
        }catch (JSONException E){
            return JSON.toJSONString(new ArrayList(){{
                add(str);
            }});
        }
    }
    public static void 获取逻辑并依次执行(String sen,boolean 是否添加当前句子)throws Exception{
        Map<String,List<String>> 处理逻辑集合 = 获取处理逻辑(sen);
        for(Map.Entry<String,List<String>> entry:处理逻辑集合.entrySet()){
            if(entry.getValue() !=null && entry.getValue().contains(sen)){
                continue;
            }
            if(entry.getValue() !=null && 是否添加当前句子){
                Util.增加成分(new 成分().setRenwu(常量.当前输入句子).setShuxing(entry.getKey()).setGuanxi(常量.是));
            }
            执行思维集合(JSON.toJSONString(entry.getValue()),是否添加当前句子);
        }
    }

    public static Map<String,List<String>> 获取预处理逻辑(List<String> list){
        Map<String,List<String>> map = new LinkedHashMap<>();
        for(String luoji:list){
            map.put(luoji,JSON.parseArray(获取待解释词(luoji),String.class));
        }
        return map;
    }
    public static Map<String,List<String>> 获取处理逻辑 (String sen){
        Map<String,List<String>> map =new HashMap<>();
        map.put(sen,JSON.parseArray(获取待解释词(sen),String.class));
        return map;
    }
    public static boolean 执行思维集合(String json,boolean 是否添加当前句子) throws Exception{
        //递归执行，如果执行思维语句中包含子思维，则递归执行
        List<String> collect = JSON.parseArray(json,String.class);
        if(CollectionUtils.isEmpty(collect)){
            return false;
        }
        for(String sen:collect){
            Util.增加成分(new 成分().setRenwu(常量.当前句子).setShuxing(sen).setGuanxi(常量.是));
            获取逻辑并依次执行(sen,是否添加当前句子);
            CopyOnWriteArrayList<String> 方法集合 =依次找方法(可行性分析.methodnames,sen);
            String 当前句子方法集合 =JSON.toJSONString(方法集合);
            Util.历史逻辑处理前的判断(是否添加当前句子);
            if(StringUtils.isNotEmpty(当前句子方法集合)){
                Util.执行方法逻辑(JSON.parseArray(当前句子方法集合,String.class));
            }
        }
        return true;
    }

    public static boolean 执行思维集合2(String json){
        List<String> collect =JSON.parseArray(json,String.class);
        if(CollectionUtils.isEmpty(collect)){
            return false;
        }
        for(String sen:collect){
            Util.增加成分(new 成分().setRenwu(常量.当前句子).setShuxing(sen).setGuanxi(常量.是));
            CopyOnWriteArrayList<String> 方法集合 = 依次找方法(可行性分析.methodnames,sen);
            try{
                int 执行的方法个数 = Util.执行方法逻辑(方法集合);
            }catch (Exception e){
                e.printStackTrace();
                return false;
            }
        }
        return true;
    }

    public static String 获取最新句子思维集合(String 句子){
        AtomicInteger index =new AtomicInteger(0);
        成分 chengfen = 可行性分析.chengfenList.stream().filter(m ->{
            index.getAndIncrement();
            return m!=null && m.shuxing !=null && m.shuxing.equals(句子) && m.shuxing.startsWith(常量.输入是);
        }).findFirst().orElse(null);
        if(null == chengfen) return null;
        int startindex =  获取下一次输入下标(index.get(), 常量.输入是);
        List<成分> list = 可行性分析.chengfenList.subList(startindex,index.get());
        List<String> collect = list.stream().filter(m->m!=null && m.renwu !=null && m.renwu.equals(常量.当前句子))
                .map(m->m.shuxing).collect(Collectors.toList());
        return JSON.toJSONString(collect);
    }

    private static int 获取下一次输入下标(int index,String 判断词){
        for(int i=index -1;i==0;i--){
            成分 m = 可行性分析.chengfenList.get(i);
            if(m!=null && m.shuxing!=null && m.shuxing.startsWith(判断词))return i+1;
        }
        return 0;
    }

    public static int 执行方法逻辑(List<String> 方法集合) throws Exception{
        int num =0;
        for(int i=0;i<方法集合.size();i++){
            num++;
            String methodname = 方法集合.get(i);
            反射执行指定方法(methodname);
        }
        return num;
    }
    public static void 反射执行指定方法(String methodname) throws Exception{
        clz.getDeclaredMethod(methodname).invoke(obj);
    }
    public static void 方法出错对变量的处理(){}
    public static void 获取当前方法中的变量(String... args){
        List<String> list =new ArrayList<>();
        for(int i=0;i<args.length;i++){
            list.add(args[i]);
        }
        Util.增加成分(new 成分().setRenwu(常量.方法变量集合).setShuxing(JSON.toJSONString(list)).setGuanxi(常量.是));
    }
    public static 成分 获取指定下标(int index){
        return 可行性分析.chengfenList.get(index);
    }
    public static 成分 获取最新成分(String renwu){
        成分 chengfen = 可行性分析.chengfenList.stream().filter(m->m!=null && renwu.equals(m.renwu)).findFirst().orElse(null);
        return chengfen;
    }
    public static String 获取最新成分属性(String renwu){
        if(StringUtils.isNotEmpty(renwu) && 常量.上一步结果.equals(renwu)){
            return 可行性分析.上一步结果;
        }
        if(StringUtils.isNotEmpty(renwu) && 常量.集合数据.equals(renwu)){
            return 可行性分析.集合数据;
        }
        成分 chengfen = 可行性分析.chengfenList.stream().filter(m->m !=null && renwu.equals(m.renwu))
                .findFirst().orElse(null);
        if(null != chengfen){
            return chengfen.shuxing;
        }
        return null;
    }

    public static String 动态查询字段所有值(String 字段名){
        List<Object> collect=可行性分析.chengfenList.stream().filter(m->m!=null)
                .map(m->m.getValue(m,字段名)).filter(m->m!=null).collect(Collectors.toList());
        return JSON.toJSONString(collect);
    }
    public static String 获取最新的一组逻辑集合(String 待解释词){
        List<成分> result =获取待解释词成分(待解释词,true);
        if(CollectionUtils.isEmpty(result)){
            return null;
        }
        List<String> collect = result.stream().map(m->m.getShuxing()).collect(Collectors.toList());
        return JSON.toJSONString(collect);
    }
    public static List<String> 获取所有有逻辑的被解释词(){
        Map<String,List<成分>> collect = 可行性分析.chengfenList.stream().filter(m->m!=null && StringUtils.isNotEmpty(m.explained))
                .collect(Collectors.groupingBy(成分::getExplained));
        List<String> collect1=collect.entrySet().stream().filter(m->m.getValue().size()>1 && 常量.待解释词是空.equals(m.getValue().get(0).getShuxing()))
                .map(m->m.getKey()).distinct().collect(Collectors.toList());
        return collect1;
    }
    //获取待解释词必须要以“待解释词是空”结尾
    public static String 获取待解释词(String 待解释词){
        List<成分> result = 获取待解释词成分(待解释词,false);
        if(CollectionUtils.isEmpty(result)){
            return null;
        }
        List<String> collect = result.stream().map(m-> m.getShuxing()).collect(Collectors.toList());
        return JSON.toJSONString(collect);
    }
    //根据 待解释词是空 区分多组 待解释词逻辑，取最新的
    public static List<成分> 获取待解释词成分(String 待解释词, boolean 是否加入待解释词是空){
        List<成分> collect = 可行性分析.chengfenList.stream().filter(m->m!=null && 待解释词 !=null
        && 待解释词.equals(m.explained)).collect(Collectors.toList());
        if(CollectionUtils.isEmpty(collect)){
            return null;
        }
        Collections.reverse(collect);
        Map<Integer,Integer> 待解释词是空在逻辑中的位置 =new HashMap<>();
        int num=0;
        for(int i=0;i<collect.size();i++){
            if(collect.get(i) !=null && 常量.待解释词是空.equals(collect.get(i).getShuxing())){
                num++;
                待解释词是空在逻辑中的位置.put(num,i);
            }
        }
        if(num<1){
            return null;
        }
        if(是否加入待解释词是空){
            if(待解释词是空在逻辑中的位置.get(num-1)==null){
                return collect.subList(0,待解释词是空在逻辑中的位置.get(num)+1);
            }else {
                return collect.subList(待解释词是空在逻辑中的位置.get(num-1)+1,待解释词是空在逻辑中的位置.get(num)+1);
            }
        }else{
            if(待解释词是空在逻辑中的位置.get(num-1)==null){
                return collect.subList(0,待解释词是空在逻辑中的位置.get(num));
            }else {
                return collect.subList(待解释词是空在逻辑中的位置.get(num-1)+1,待解释词是空在逻辑中的位置.get(num));
            }
        }
    }
    public static String 获取有逻辑的待解释词(String 待解释词){
        List<成分> result = 获取待解释词成分(待解释词,false);
        if(CollectionUtils.isNotEmpty(result)){
            return result.get(0).getExplained();
        }
        return null;
    }

    public static String 根据关系查询人物(String 关系){
        List<String> collect =可行性分析.chengfenList.stream().filter(m -> m!=null &&
                关系.equals(m.guanxi)).map(m->m.renwu).collect(Collectors.toList());
        return JSON.toJSONString(collect);
     }
     public static String 获取成分属性(String 人物,String 关系){
        List<String> collect = 可行性分析.chengfenList.stream().filter(m->m!=null && 人物.equals(m.renwu)
        && 关系.equals(m.guanxi)).map(m->m.shuxing).collect(Collectors.toList());
        return JSON.toJSONString(collect);
     }
    public static String 获取成分人物(String 属性,String 关系){
        List<String> collect = 可行性分析.chengfenList.stream().filter(m->m!=null && 属性.equals(m.shuxing)
                && 关系.equals(m.guanxi)).map(m->m.renwu).collect(Collectors.toList());
        return JSON.toJSONString(collect);
    }
    public static String 获取成分关系(String 人物,String 属性){
        List<String> collect = 可行性分析.chengfenList.stream().filter(m->m!=null && 人物.equals(m.renwu)
                && 属性.equals(m.shuxing)).map(m->m.guanxi).collect(Collectors.toList());
        return JSON.toJSONString(collect);
    }
    public static synchronized void 增加成分(成分 chengfen ){
        if(chengfen == null ) return;
        if(StringUtils.isNotEmpty(chengfen.getRenwu()) && chengfen.getRenwu().equals(常量.上一步结果)){
            可行性分析.上一步结果=chengfen.getShuxing();
            return;
        }
        if(StringUtils.isNotEmpty(chengfen.getRenwu()) && chengfen.getRenwu().equals(常量.集合数据)){
            可行性分析.集合数据=chengfen.getShuxing();
            return;
        }
        可行性分析.chengfenList.add(0,chengfen);
        Util.保存成分(chengfen);
    }
    public static void 保存成分(成分 chengfen){
        if(chengfen !=null){
            try{
                Util.writeFile(可行性分析.chengfenFilenames[可行性分析.chengfenFilenames.length-1],JSON.toJSONString(chengfen),true);
            }catch (IOException ioException){
                ioException.printStackTrace();
            }
        }
    }
    public static String 返回list集合(String str){
        return JSON.toJSONString(new ArrayList(){{
            add(str);
        }});
    }
    public static String 分割并返回list集合(String str,String split){
        return JSON.toJSONString(Stream.of(str.split(split)).collect(Collectors.toList()));
    }
    public static void 询问找参数(String sen,String methodName,int num){
        String format ="'%s'中动作 '%s'的参数%s是什么？";
        System.out.println(String.format(format,sen,methodName,num));
    }
    public static boolean 数组中的所有元素是否在字符串中(String[] paramArr,String sen){
        for(String arr1:paramArr){
            if(!sen.contains(arr1)){
                return false;
            }
        }
        return true;
    }

    public static void 删除集合中的子集合(CopyOnWriteArrayList<String> 方法集合,CopyOnWriteArrayList<String> 方法集合2){
        String a =String.join(" ",方法集合);
        String b =String.join(" ",方法集合2);
        List<String> collect = Arrays.asList(StringUtils.removeFirst(a,b).split("\\s+"));
        方法集合.clear();
        方法集合.addAll(new CopyOnWriteArrayList<>(collect));
    }
    public static boolean exist(String filename) throws IOException{
        File file =new File(filename);
        if(file.exists()){
            return true;
        }
        boolean newFile = file.createNewFile();
        return newFile;
    }
    public static void writeFile(String filename,String str,boolean append)throws IOException{
        if(!exist(filename)){
            return;
        }
        FileWriter fileWriter=new FileWriter(filename,append);
        fileWriter.write("\n");
        fileWriter.write(str);
        fileWriter.flush();
        fileWriter.close();
    }
    public static List<String> readFileByLine(String filename) throws IOException{
        if(!exist(filename)){
            return null;
        }
        File file=new File(filename);
        BufferedReader bufferedReader=new BufferedReader(new FileReader(file));
        String str=null;
        List<String> list =new ArrayList<>();
        while ((str =bufferedReader.readLine())!=null){
            list.add(str);
        }
        bufferedReader.close();
        //反转倒序
        Collections.reverse(list);
        return list;
    }
    public static CopyOnWriteArrayList<String> 依次找方法(Set<String> methodnames,String sen){
        CopyOnWriteArrayList<String> 当前流程方法集合=new CopyOnWriteArrayList<>();
        for(int i=0;i<sen.length();i++){
            递归找方法(methodnames,当前流程方法集合,i,i+1,sen);
            int temp = 当前流程方法集合.size()==0?i:String.join("",当前流程方法集合).length()<i?i:
                    String.join("",当前流程方法集合).length();
            if(temp!=i){
                i=temp-1;
            }
        }
        return 当前流程方法集合;
    }
    public static int 递归找方法(Set<String> methodnames,List<String> list,int start,int end,String sen) {
        if (end > sen.length() && 集合任一元素是否包含(methodnames, sen.substring(start, end - 1))
                && methodnames.contains(sen.substring(start, end - 1))) {
            list.add(sen.substring(start, end - 1));
        }
        if (end > sen.length()) {
            return sen.length();
        }
        if (集合任一元素是否包含(methodnames, sen.substring(start, end))) {
            递归找方法(methodnames, list, start, end + 1, sen);
        } else {
            if (end - start == 1) {
                return start;
            } else {
                if (methodnames.contains(sen.substring(start, end - 1))) {
                    list.add(sen.substring(start, end - 1));
                }
                return end - 1;
            }
        }
        return start;
    }
    public static boolean 集合任一元素是否包含(Set<String> list,String str){
        boolean flag =false;
        for(String item:list){
            if(item.startsWith(str)){
                flag=true;
                break;
            }
        }
        return flag;
    }
    public static Set<String> 获取所有内部方法(){
        return 可行性分析.methodnames;
    }
}

两句子的唯一区别判断

package 工具;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import 入口.可行性分析;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class 两句子的唯一区别判断 {
    public static void main(String[] args) {
        可行性分析.init();
        List<String> wordList = 获取成分集合中所有单词();
        String sen1 = "被分割词是疑问句子";
        String sen2 = "被分割词是包含词是5";
        List<String> 句子中所有词组合 =句子中所有词组合(wordList,sen1);
        List<List<String>> 句子中所有词组合s =循环对句子中的词组合组装(句子中所有词组合);
        List<String> 句子中所有词组合2 = 句子中所有词组合(wordList,sen2);
        List<List<String>> 句子中所有词组合2s =循环对句子中的词组合组装(句子中所有词组合2);
        System.out.println(获取所有词组合等于1的句子词组集合(句子中所有词组合,句子中所有词组合2s));
//        System.out.println(判断两个集合元素不同的个数(句子中所有词组合,句子中所有词组合2));

    }
    public static List<String> 获取所有词组合等于1的句子词组集合(List<String> 句子中所有词组合,List<List<String>> 句子中所有词组合2s ){
        for(List<String> item2:句子中所有词组合2s){
            if(1 == 判断两个集合元素不同的个数(句子中所有词组合,item2)){
                return item2;
            }
        }
        return null;
    }
    public static List<String> 获取两个集合元素等于1的句子词组集合(List<List<String>> 句子中所有词组合s,List<List<String>> 句子中所有词组合2s){
        for(List<String> item:句子中所有词组合s){
            for(List<String> item2:句子中所有词组合2s){
                if(1==判断两个集合元素不同的个数(item,item2)){
                    return item2;
                }
            }
        }
        return null;
    }
    public static List<List<String>> 循环对句子中的词组合组装(List<String> 句子中所有词组合){
        List<List<String>> result = new ArrayList<>();
        result.add(句子中所有词组合);
        int num=2;
        while(num+1<句子中所有词组合.size()){
            对句子中的词组合组装(result,句子中所有词组合,num);
            num++;
        }
        return result;
    }
    public static void 对句子中的词组合组装(List<List<String>> result,List<String> 句子中所有词组合,int num){
        if(句子中所有词组合.size()<=num){
            return;
        }
        for(int i=0;i<句子中所有词组合.size();i++){
            List<String> list =new ArrayList<>();
            String 新词组 = "";
            for(int j=i;j<i+num;j++){
                新词组 += 句子中所有词组合.get(j);
            }
            list.addAll(句子中所有词组合.subList(0,i));
            list.add(新词组);
            list.addAll(句子中所有词组合.subList(i+num,句子中所有词组合.size()));
            result.add(list);
            if(i+num >=  句子中所有词组合.size()){
                break;
            }
        }
    }
    public static String 获取唯一区别教学语句(List<String> 待验证教学集合,String sen){
        List<String> wordlist = 获取成分集合中所有单词();
        List<String> 句子中所有组合2=句子中所有词组合(wordlist,sen);
        List<List<String>> 句子中所有词组合2s = 循环对句子中的词组合组装(句子中所有组合2);
        if(CollectionUtils.isEmpty(待验证教学集合))return null;
        String result = 待验证教学集合.stream().filter(m->{
            List<String> 句子中所有词组合 = 句子中所有词组合(wordlist,m);
            List<String> 匹配的句子 =获取所有词组合等于1的句子词组集合(句子中所有词组合,句子中所有词组合2s);
            if(CollectionUtils.isNotEmpty(匹配的句子)){
                return true;
            }
            return false;
        }).findFirst().orElse(null);
        return result;
    }
    public static List<String> 获取成分集合中所有单词(){
        List<String> wordlist=new ArrayList<>();
        wordlist.addAll(可行性分析.chengfenList.stream().map(m->m.renwu).distinct().collect(Collectors.toList()));
        wordlist.addAll(可行性分析.chengfenList.stream().map(m->m.shuxing).distinct().collect(Collectors.toList()));
        wordlist.addAll(可行性分析.chengfenList.stream().map(m->m.guanxi).distinct().collect(Collectors.toList()));
        wordlist=wordlist.stream().distinct().collect(Collectors.toList());
        return wordlist;
    }
    public static List<String> 句子中所有词组合(List<String> wordlist,String sen){
        List<String> collect =wordlist.stream().filter(m->m!=null && sen !=null && sen.contains(m) && m.length()>1
        && !m.equals(sen)).collect(Collectors.toList());
        //加入内部变量名
        collect.addAll(替换逻辑集合中的变量.获取所有常量名());
        collect= collect.stream().distinct().collect(Collectors.toList());
        //排除掉集合中项目包含词
        List<String> result =new ArrayList<>();
        句子中所有词组合sub(collect,sen,result);
        return result;
    }
    //保留长度最小的
    public static void 排除掉集合中互相包含词(List<String> collect){
        List<String> result = new ArrayList<>();
        result.addAll(collect);
        result.stream().forEach(m->{
            for(int i=0;i<collect.size();i++){
                if(collect.get(i).length()>m.length() && collect.get(i).contains(m)){
                    collect.remove(i);
                }
            }
        });
    }
    public static void 句子中所有词组合sub(List<String> worList,String sen,List<String> result){
        List<String> collect1=worList.stream().filter(m-> m!= null && sen.startsWith(m)).collect(Collectors.toList());
        if(StringUtils.isEmpty(sen)){
            return;
        }
        String 词语块=sen.substring(0,1);
        if(CollectionUtils.isNotEmpty(collect1)){
            词语块=collect1.stream().sorted((a,b)->{
                if(a.length()<b.length()){
                    return 1;
                }
                return -1;
            }).findFirst().get();
        }
        if(!判断上一个词是否是已知词(worList,result)){
            result.add(result.get(result.size()-1)+词语块);
            result.remove(result.size()-2);
        }else {
            result.add(词语块);
        }
        if(sen.length()==1){
            return;
        }
        String newsen =sen.substring(词语块.length());
        句子中所有词组合sub(worList,newsen,result);
    }
    public static boolean 判断上一个词是否是已知词(List<String> wordList,List<String> result){
        if(CollectionUtils.isEmpty(result)){
            return true;
        }
        return wordList.contains(result.get(result.size()-1));
    }
    public static int 判断两个集合元素不同的个数(List<String> list1,List<String> list2){
        if(list1.size()<=1 || list2.size()<=1){
            return 0;
        }
        if(list1.size()!=list2.size()){
            String temp1=String.join("",list1);
            String temp2=String.join("",list2);
            if(temp1.contains(temp2)|| temp2.contains(temp1)){
                return 1;
            }
            return 0;
        }
        int num=0;
        for(int i=0;i<list1.size();i++){
            if(!StringUtils.equals(list1.get(i),list2.get(i))){
                num++;
            }
        }
        return num;
    }
}

分组

package 工具;

import com.alibaba.fastjson.JSON;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class 分组 {
    public static void main(String[] args) {
        List<String> list =new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("dd");
        list.add("aa");
        list.add("cc");
        list.add("bb");
        list.add("aa");
        String result = JSON.toJSONString(对集合数据分组(list));
        Map<String,Integer> map = JSON.parseObject(result,Map.class);
        System.out.println(过滤大于指标的分组集合(map,2));
    }
    public static List<String> 过滤大于指标的分组集合(Map<String,Integer> map,int index){
        List<String> collect = map.entrySet().stream().filter(m->m.getValue() >=
                index).map(m->m.getKey()).collect(Collectors.toList());
        return collect;
    }
    public static Map<String,Integer> 对集合数据分组(List<String> list){
        Map<String,Integer> result = new HashMap<>();
        while(list.size()>0){
            int num=0;
            String temp = list.get(0);
            while(list.indexOf(temp)>=0){
                int k = list.indexOf(temp);
                if(k>=0){
                    num++;
                    list.remove(k);
                }
            }
            result.put(temp,num);
        }
        return result;
    }
}

历史逻辑处理

package 工具;

import 实体.成分;

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

public class 历史逻辑处理 {
    public static List<成分>  存放临时逻辑状态 = new ArrayList<>();
//    public static void 还原逻辑前的键值状态        ;
}

常量

package 工具;

public class 常量 {
    public static final String 空 = "空";
    public static final String 是什么 = "是什么";
    public static final String 空值 = "";
    public static final String 待解释词是空 = "待解释词是空";
    public static final String 上一句话 = "上一句话";
    public static final String 输入 = "输入";
    public static final String 输出 = "输出";
    public static final String 输入是 = "输入是";
    public static final String 待解释词 = "待解释词";
    public static final String 当前对话人 = "当前对话人";
    public static final String 当前人 = "当前人";
    public static final String 人物 = "人物";
    public static final String 属性 = "属性";
    public static final String 关系 = "关系";
    public static final String 当前句子 = "当前句子";
    public static final String 当前逻辑句子 = "当前逻辑句子";
    public static final String 当前句子方法集合 = "当前句子方法集合";
    public static final String 当前输入句子 = "当前输入句子";
    public static final String 序号词 = "序号词";
    public static final String 意向词 = "意向词";
    public static final String 意向词的值 = "意向词的值";
    public static final String 上一步结果 = "上一步结果";
    public static final String 上一次判断结果 = "上一次判断结果";
    public static final String 上一次判断结果是 = "上一次判断结果是";
    public static final String 是 = "是";
    public static final String 下标 = "下标";
    public static final String 判断条件1 = "判断条件1";
    public static final String 判断条件2 = "判断条件2";
    public static final String TRUE = "true";
    public static final String 集合数据 = "集合数据";
    public static final String 分组数据 = "分组数据";
    public static final String 被加数 = "被加数";
    public static final String 加数 = "加数";
    public static final String 减数 = "减数";
    public static final String 被减数 = "被减数";
    public static final String 被乘数 = "被乘数";
    public static final String 乘数 = "乘数 =";
    public static final String 被除数 = "被除数";
    public static final String 除数 = "除数";
    public static final String 被包含词 = "被包含词";
    public static final String 包含词 = "包含词";
    public static final String 方法变量集合 = "方法变量集合";
    public static final String 预处理逻辑 = "预处理逻辑";
    public static final String 判断逻辑 = "判断逻辑";
    public static final String 逻辑集合 = "逻辑集合";
    public static final String 分割词 = "分割词";
    public static final String 被分割词 = "被分割词";
    public static final String 分割个数 = "分割个数";
    public static final String 获取预处理逻辑 = "获取预处理逻辑";
    public static final String 执行预处理逻辑 = "执行预处理逻辑";
    public static final String 循环体 = "循环体";
    public static final String 循环数据 = "循环数据";
    public static final String 当前循环数据 = "当前循环数据";
    public static final String 尝试用历史思维处理 = "尝试用历史思维处理";
    public static final String 查询待解释词 = "查询待解释词";
    public static final String 过滤条件 = "过滤条件";
    public static final String 循环参数键1 = "循环参数键1";
    public static final String 循环参数键2 = "循环参数键2";
    public static final String 预处理结果 = "预处理结果";
    public static final String 要查询的字段 = "要查询的字段";
    public static final String 指标 = "指标";
    public static final String 组装词1 = "组装词1";
    public static final String 组装句子 = "组装句子";
    public static final String 组装词2 = "组装词2";
    public static final String 待处理句子 = "待处理句子";
    public static final String 待处理词 = "待处理词";
    public static final String 疑问词 = "疑问词";
    public static final String 疑问句子 = "疑问句子";
    public static final String 被删除句子 = "被删除句子";
    public static final String 删除词 = "删除词";
    public static final String 当前句子返回结果 = "当前句子返回结果";
    public static final String 内部方法的错误信息 = "内部方法的错误信息";
    public static final String 前面 = "前面";

}

替换句子汇总的相似成分

package 工具;

import com.alibaba.fastjson.JSON;
import org.apache.commons.collections4.CollectionUtils;
import 入口.可行性分析;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class 替换句子汇总的相似成分 {
    private static List<String> wordlist = null;

    public static void main(String[] args) {
        可行性分析.init();
        wordlist = 两句子的唯一区别判断.获取成分集合中所有单词();
        String sen1 = "判断四4是否包含43";
        Map<String,List<String>> 句子中所有词组合 = 查询句子词组的相似词(sen1,"相似");
        List<String> result =替换相似词形成新句子(sen1,sen1);
        System.out.println(result);
    }
    public static List<String> 替换相似词形成新句子(String sen,String 相似){
        wordlist = 两句子的唯一区别判断.获取成分集合中所有单词();
        Map<String,List<String>> 词组与其相似集合 = 查询句子词组的相似词(sen,相似);
        List<String> result = new ArrayList<>();
        词组与其相似集合.forEach((k,v) ->{
            String senTemp =sen ;
            for(String m:v){
                senTemp =sen.replace(k,m);
            }
            result.add(senTemp);
        });
        return result;
    }
    public static Map<String, List<String>> 查询句子词组的相似词(String sen,String 相似){
        List<String> 句子中所有词组组合 = 两句子的唯一区别判断.句子中所有词组合(wordlist,sen);
        Map<String,List<String>> map =new HashMap<>();
        for(String sen1:句子中所有词组组合){
            List<String> strings = JSON.parseArray(Util.获取成分属性(sen1,相似),String.class);
            List<String> strings2 = JSON.parseArray(Util.获取成分人物(sen1,相似),String.class);
            if(CollectionUtils.isNotEmpty(strings)){
                strings.addAll(strings2);
                map.put(sen1,strings);
            }else if(CollectionUtils.isNotEmpty(strings2)){
                strings2.addAll(strings);
                map.put(sen1,strings2);
            }else {
                continue;
            }
        }
        return map;
    }
}

替换逻辑集合中的变量

package 工具;

import com.alibaba.fastjson.JSON;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import 入口.可行性分析;
import 实体.成分;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class 替换逻辑集合中的变量 {
    public static void main(String[] args) {
        可行性分析.init();
        List<String> wordlist = 两句子的唯一区别判断.获取成分集合中所有单词();
        String 原句 = "输出包含";
        String 当前句 = "输出不包含";
        List<String> 原句中所有词组合 = 两句子的唯一区别判断.句子中所有词组合(wordlist,原句);
        List<String> 当前句中所有词组合 = 两句子的唯一区别判断.句子中所有词组合(wordlist,当前句);
        List<List<String>> 句子中所有词组合2s= 两句子的唯一区别判断.循环对句子中的词组合组装(当前句中所有词组合);
        当前句中所有词组合 = 两句子的唯一区别判断.获取所有词组合等于1的句子词组集合(原句中所有词组合,句子中所有词组合2s);
        List<String> 逻辑集合 = JSON.parseArray(Util.获取最新的一组逻辑集合(原句),String.class);
        List<String> 所有常量名 = 获取所有常量名();
        List<String> 找出逻辑语句中的变量并替换 = 找出逻辑语句中的变量并替换(原句,当前句,逻辑集合,所有常量名,原句中所有词组合,当前句中所有词组合);
        System.out.println(找出逻辑语句中的变量并替换);
    }
    public static List<String> 获取新的逻辑集合(String 原句,String 当前句){
        if(StringUtils.isEmpty(原句) || StringUtils.isEmpty(当前句)){
            return null;
        }
        List<String> wordlist = 两句子的唯一区别判断.获取成分集合中所有单词();
        List<String> 原句中所有词组合 = 两句子的唯一区别判断.句子中所有词组合(wordlist,原句);
        List<String> 当前句中所有词组合  = 两句子的唯一区别判断.句子中所有词组合(wordlist,当前句);
        List<List<String>> 句子中所有词组合2s= 两句子的唯一区别判断.循环对句子中的词组合组装(当前句中所有词组合);
        当前句中所有词组合 = 两句子的唯一区别判断.获取所有词组合等于1的句子词组集合(原句中所有词组合,句子中所有词组合2s);
        List<String> 逻辑集合 = JSON.parseArray(Util.获取最新的一组逻辑集合(原句),String.class);
        List<String> 所有常量名 = 获取所有常量名();
        List<String> 找出逻辑语句中的变量并替换 = 找出逻辑语句中的变量并替换(原句,当前句,逻辑集合,所有常量名,原句中所有词组合,当前句中所有词组合);
        return 找出逻辑语句中的变量并替换;
    }
    public static void 保存生成的逻辑集合(String explained, List<String> list){
        if(CollectionUtils.isEmpty(list)){
            return;
        }
        Util.增加成分(new 成分().setRenwu("------------------------------------start-----------------------------------------------------")
        .setShuxing("唯一区别生成的逻辑集合"));
        for(String m:list){
            Util.增加成分(new 成分().setRenwu(常量.当前句子).setGuanxi(常量.是).setShuxing(m).setExplained(explained));
        }
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setGuanxi(常量.是).setShuxing(explained));
        Util.增加成分(new 成分().setRenwu("------------------------------------end-----------------------------------------------------")
                .setShuxing("唯一区别生成的逻辑集合"));
    }
    public static List<String> 获取所有常量名(){
        Field[] fields = new 常量().getClass().getFields();
        List<String> list =new ArrayList<>();
        for(Field field:fields){
            list.add(field.getName());
        }
        return list;
    }
    public static List<String> 找出逻辑语句中的变量并替换(String 原句,String 当前句,List<String> 逻辑集合,List<String> 所有常量名,List<String> 原句词语块,List<String> 当前句词语块){
        List<String> list = new ArrayList<>();
        if(CollectionUtils.isEmpty(逻辑集合)){
            return null;
        }
        if(原句词语块.size() != 当前句词语块.size()){
            return null;
        }
        for(String luoji:逻辑集合){
            String newluoji =luoji;
            for(String name:所有常量名){
                String key = name + 常量.是;
                if(!luoji.startsWith(key)){
                    continue;
                }
                String value = luoji.substring(key.length());
                if(原句.equals(value)){
                    newluoji = key+当前句;
                    break;
                }
                if(!原句词语块.contains(value)){
                    continue;
                }
                int 要替换词在原句子中的位置 = 原句词语块.indexOf(value);
                String value替换为当前句子中的词 =当前句词语块.get(要替换词在原句子中的位置);
                newluoji=key+value替换为当前句子中的词;
                break;
            }
            list.add(newluoji);
        }
        return list;
    }
    public static List<String> 找出逻辑语句中的变量并替换(List<String> 逻辑集合,List<String> 所有常量名,String 原句,String 当前句){
        List<String> list = new ArrayList<>();
        for(String luoji:逻辑集合){
            String newluoji = luoji;
            for(String name:所有常量名){
                String key = name + 常量.是;
                if(!luoji.startsWith(key)){
                    continue;
                }
                String value = luoji.substring(key.length());
                if(!原句.contains(value)){
                    continue;
                }
                int 要替换词在原句子中的位置 = 原句.indexOf(value);
                String value替换为当前句子中的词 =  当前句.substring(要替换词在原句子中的位置,要替换词在原句子中的位置+value.length());
                newluoji =key+value替换为当前句子中的词;
            }
            list.add(newluoji);
        }
        return list;
    }
}

父子节点排序

package 工具;

import com.alibaba.fastjson.JSON;
import 入口.可行性分析;

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

public class 父子节点排序 {

    public static void main(String[] args) {
        可行性分析.init();
        List<String> list = new ArrayList<>();
        list.add("获取唯一区别教学语句");
        list.add("对句子做相似处理");
        list.add("获取有逻辑的待解释词");

        父子节点排序(list,"前面");
        System.out.println(list);
    }

    //
    public static void 父子节点排序(List<String> list,String 比较词){
        for(int i=0;i<list.size();i++){
            String renwu= list.get(i);
            List<String> shuxings = JSON.parseArray(Util.获取成分属性(renwu,比较词),String.class);
            for(String shuxing:shuxings){
                int index = list.indexOf(shuxing);
                if(index>=0){
                    if(index <i){
                        list.remove(i);
                        list.add(index,renwu);
                    }
                }
            }
        }
    }
}

获取句子中的未知词

package 工具;

import com.alibaba.fastjson.JSON;
import org.apache.commons.collections4.CollectionUtils;
import 入口.可行性分析;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class 获取句子中的未知词 {
    public static void main(String[] args) {
        可行性分析.init();
        List<String> 集合数据= JSON.parseArray(Util.获取最新成分属性(常量.集合数据),String.class);
        集合数据.add("sd");
        List<String> wordlist= 两句子的唯一区别判断.获取成分集合中所有单词();
        String sen = "当前输入句子的待处理句子";
        String sen2="222";
        System.out.println(获取句子中的未知词(sen));
    }

    public static List<String> 获取句子中的未知词(String sen){
        String 关系 = 常量.是;
        String aa=Util.根据关系查询人物(关系);
        List<String> list=JSON.parseArray(aa,String.class);
        list.addAll(可行性分析.methodnames);
        List<String> result = 获取句子中的未知词(sen,list);
        return result;
    }

    public static List<String> 获取句子中的未知词(String sen,List<String> 已知词){
        已知词=已知词.stream().distinct().collect(Collectors.toList());
        List<String> words = new ArrayList<>();
        int sen中的词一次也没出现在已知词 = 0;
        for(String str:已知词){
            if(!sen.contains(str)){
                sen中的词一次也没出现在已知词++;
                continue;
            }
            words.addAll(Stream.of(sen.split(str)).collect(Collectors.toList()));
            words=words.stream().distinct().collect(Collectors.toList());
        }
        if(sen中的词一次也没出现在已知词 == 已知词.size())words.add(sen);
        words=从一个集合中排除在另一个集合中的数据(words,已知词);
        return words;
    }

    public static List<String> 从一个集合中排除在另一个集合中的数据(List<String> 被排除集合,List<String> 排除集合){
        if(CollectionUtils.isEmpty(被排除集合) || CollectionUtils.isEmpty(排除集合)){
            return 被排除集合;
        }
        for(int i=0;i<被排除集合.size();i++){
            if(排除集合.contains(被排除集合.get(i))){
                被排除集合.remove(i);
                i--;
            }
        }
        return 被排除集合;
    }
}

预处理逻辑之间相互处理功能

package 工具;

public class 预处理逻辑之间相互处理功能 {
}

不执行后方法异常

package 异常;

public class 不执行后方法异常 extends Exception {
    public 不执行后方法异常(){
        super();
    }
    public 不执行后方法异常(String message){
        super(message);
    }
}

处理方法

package 执行;

import com.alibaba.fastjson.JSON;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import 实体.成分;
import 工具.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class 处理方法 {

    public void 是(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String[] arrs=Util.获取最新成分属性(常量.当前句子).split(Thread.currentThread().getStackTrace()[1].getMethodName(),2);
        if(arrs.length<2)return;
        Util.增加成分(new 成分().setRenwu(arrs[0]).setShuxing(arrs[1]).setGuanxi(Thread.currentThread().getStackTrace()[1].getMethodName()));
    }

    public void 相似(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String[] arrs=Util.获取最新成分属性(常量.当前句子).split(Thread.currentThread().getStackTrace()[1].getMethodName(),2);
        if(arrs.length<2)return;
        Util.增加成分(new 成分().setRenwu(arrs[0]).setShuxing(arrs[1]).setGuanxi(Thread.currentThread().getStackTrace()[1].getMethodName()));
    }
    public void 小于(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String[] arrs=Util.获取最新成分属性(常量.当前句子).split(Thread.currentThread().getStackTrace()[1].getMethodName(),2);
        if(arrs.length<2)return;
        Util.增加成分(new 成分().setRenwu(arrs[0]).setShuxing(arrs[1]).setGuanxi(Thread.currentThread().getStackTrace()[1].getMethodName()));
    }

    public void 还原上一次判断结果为正确(){
        Util.增加成分(new 成分().setRenwu(常量.上一次判断结果).setShuxing("true").setGuanxi(常量.是));
    }

    public void 获取集合中的下标(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        int 下标=Integer.parseInt(Util.获取最新成分属性(常量.下标));
        List<String> list = JSON.parseArray(Util.获取最新成分属性(常量.上一步结果),String.class);
        if(CollectionUtils.isNotEmpty(list)){
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(list.get(下标)).setGuanxi(常量.是));
        }
    }

    public void 输出上一步结果(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        System.out.println(常量.上一步结果+"是: "+Util.获取最新成分属性(常量.上一步结果));
    }

    public void 执行输出方法(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String[] arrs=Util.获取最新成分属性(常量.上一步结果).split(常量.输出,2);
        if(arrs.length<2) return;
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(arrs[1]).setGuanxi(常量.是));
        输出上一步结果();
    }

    public void 获取意向词属性(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String str  =Util.获取最新成分属性(常量.意向词);
        String shuxing=Util.获取最新成分属性(str);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(shuxing).setGuanxi(常量.是));
    }

    public void 获取意向词(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String str =Util.获取最新成分属性(常量.意向词);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(str).setGuanxi(常量.是));
    }


    public void 保存意向词的值(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.增加成分(new 成分().setRenwu(Util.获取最新成分属性(常量.意向词)).setShuxing(Util.获取最新成分属性(常量.上一步结果)).setGuanxi(常量.是));
    }

    public void 保存意向词(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.增加成分(new 成分().setRenwu(常量.意向词).setShuxing(Util.获取最新成分属性(常量.意向词的值)).setGuanxi(常量.是));

    }

    public void 获取当前解释句子(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(Util.获取最新成分属性(常量.意向词的值)).setGuanxi(常量.是));
    }
    public void 如果等于(){
        String 判断条件1=Util.获取最新成分属性(常量.判断条件1);
        String 判断条件2=Util.获取最新成分属性(常量.判断条件2);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(判断条件1.equals(判断条件2)+"").setGuanxi(常量.是));
    }

    public void 如果错误(){
        String 上一步结果=Util.获取最新成分属性(常量.上一步结果);
        Util.增加成分(new 成分().setRenwu(常量.上一次判断结果).setShuxing("false".equals(上一步结果)+"").setGuanxi(常量.是));
    }
    public void 执行分割方法(){
        String 上一步结果=Util.获取最新成分属性(常量.上一步结果);
        String 分割词=Util.获取最新成分属性(常量.分割词);
        String 被分割词=Util.获取最新成分属性(常量.被分割词);
        String 个数=Util.获取最新成分属性(常量.分割个数);
        List<String> result =null;
        if(StringUtils.isEmpty(个数)){
            result= Stream.of(被分割词.split(分割词)).collect(Collectors.toList());
        }else{
            int 分割个数=Integer.parseInt(个数);
            result=Stream.of(被分割词.split(分割词,分割个数)).collect(Collectors.toList());
        }
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(result)).setGuanxi(常量.是));
    }

    public void 删除句子中的词()throws Exception{
        String 被删除句子=Util.获取最新成分属性(常量.被删除句子);
        String 删除词=Util.获取最新成分属性(常量.删除词);
        if(被删除句子==null){
            throw new Exception ("被删除句子是什么");
        }
        if(删除词==null){
            throw new Exception("删除词是什么");
        }
        String result = 被删除句子.replace(删除词, 常量.空值);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(result).setGuanxi(常量.是));
    }

    public void 如果不等于空(){
        String 上一步结果=Util.获取最新成分属性(常量.上一步结果);
        Util.增加成分(new 成分().setRenwu(常量.上一次判断结果).setShuxing(StringUtils.isNoneBlank(上一步结果)+"").setGuanxi(常量.是));
    }
    public void 如果正确(){
        String 上一步结果=Util.获取最新成分属性(常量.上一步结果);
        Util.增加成分(new 成分().setRenwu(常量.上一次判断结果).setShuxing("true".equals(上一步结果)+"").setGuanxi(常量.是));
    }

    public void 获取判断条件1(){
        String 上一步结果=Util.获取最新成分属性(常量.上一步结果);
        Util.增加成分(new 成分().setRenwu(常量.判断条件1).setShuxing(上一步结果).setGuanxi(常量.是));
    }

    public void 否则(){
        boolean str=Boolean.parseBoolean(Util.获取最新成分属性(常量.上一次判断结果));
        str=!str;
        Util.增加成分(new 成分().setRenwu(常量.上一次判断结果).setShuxing(str+"").setGuanxi(常量.是));
    }

    public void 上一次判断结果是true(){
        Util.增加成分(new 成分().setRenwu(常量.上一次判断结果).setShuxing("true").setGuanxi(常量.是));
    }

    public void 保存成分(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 人物=Util.获取最新成分属性(常量.人物);
        String 属性=Util.获取最新成分属性(常量.属性);
        String 关系=Util.获取最新成分属性(常量.关系);
        Util.增加成分(new 成分().setRenwu(人物).setShuxing(属性).setGuanxi(关系));

    }

    public void 保存人物(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.增加成分(new 成分().setRenwu(常量.人物).setShuxing(Util.获取最新成分属性(常量.上一步结果)).setGuanxi(常量.是));

    }

    public void 保存关系(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.增加成分(new 成分().setRenwu(常量.关系).setShuxing(Util.获取最新成分属性(常量.上一步结果)).setGuanxi(常量.是));
    }
    public void 保存属性(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.增加成分(new 成分().setRenwu(常量.属性).setShuxing(Util.获取最新成分属性(常量.上一步结果)).setGuanxi(常量.是));
    }

    public void 执行思维集合() throws Exception {
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 思维集合=Util.获取最新成分属性(常量.上一步结果);
        Util.执行思维集合(思维集合,true);
    }

    public void 查询下标人物(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;

        String 下标=Util.获取最新成分属性(常量.下标);
        int index=Integer.parseInt(下标);
        成分 获取指定下标=Util.获取指定下标(index);
        if(获取指定下标!=null){
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(获取指定下标.getRenwu()).setGuanxi(常量.是));
        }else{
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(null).setGuanxi(常量.是));
        }
    }


    public void 查询下标属性(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 下标=Util.获取最新成分属性(常量.下标);
        int index=Integer.parseInt(下标);
        成分 获取指定下标=Util.获取指定下标(index);
        if(获取指定下标!=null){
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(获取指定下标.getShuxing()).setGuanxi(常量.是));
        }else{
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(null).setGuanxi(常量.是));
        }
    }


    public void 查询下标关系(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 下标=Util.获取最新成分属性(常量.下标);
        int index=Integer.parseInt(下标);
        成分 获取指定下标=Util.获取指定下标(index);
        if(获取指定下标!=null){
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(获取指定下标.getGuanxi()).setGuanxi(常量.是));
        }else{
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(null).setGuanxi(常量.是));
        }
    }

    public void 根据关系查询人物(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;

        String 关系=Util.获取最新成分属性(常量.关系);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(Util.根据关系查询人物(关系)).setGuanxi(常量.是));
    }

    public void 去重上一步结果(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;

        List<String> list=JSON.parseArray(Util.获取最新成分属性(常量.上一步结果),String.class);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(list)).setGuanxi(常量.是));
    }



    public void 查询成分属性(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 人物=Util.获取最新成分属性(常量.属性);
        String 关系=Util.获取最新成分属性(常量.关系);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(Util.获取成分属性(人物,关系)).setGuanxi(常量.是));
    }

    public void 查询成分人物(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 属性=Util.获取最新成分属性(常量.属性);
        String 关系=Util.获取最新成分属性(常量.关系);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(Util.获取成分人物(属性,关系)).setGuanxi(常量.是));
    }

    public void 查询成分关系(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 人物=Util.获取最新成分属性(常量.人物);
        String 属性=Util.获取最新成分属性(常量.属性);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(Util.获取成分关系(人物,属性)).setGuanxi(常量.是));
    }

    public void 查询待解释词(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 待解释词=Util.获取最新成分属性(常量.待解释词);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(待解释词).setGuanxi(常量.是));
    }

    public void 查询字段所有值(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 要查询的字段=Util.获取最新成分属性(常量.要查询的字段);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(Util.动态查询字段所有值(要查询的字段)).setGuanxi(常量.是));
    }

    public void 替换句子中的相似词(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 上一步结果=Util.获取最新成分属性(常量.上一步结果);

        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(Util.替换句子中的相似词(上一步结果)).setGuanxi(常量.是));
    }

    public void 对集合数据分组(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 集合数据=Util.获取最新成分属性(常量.集合数据);
        List<String> list=JSON.parseArray(集合数据,String.class);
        Util.增加成分(new 成分().setRenwu(常量.分组数据).setShuxing(JSON.toJSONString(分组.对集合数据分组(list))).setGuanxi(常量.是));
    }
    public void 过滤大于指标的集合数据(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 分组数据=Util.获取最新成分属性(常量.分组数据);
        int 指标=Integer.parseInt(Util.获取最新成分属性(常量.指标));
        Map<String,Integer> map=JSON.parseObject(分组数据,Map.class);
        Util.增加成分(new 成分().setRenwu(常量.集合数据).setShuxing(JSON.toJSONString(分组.过滤大于指标的分组集合(map,指标))).setGuanxi(常量.是));
    }

    public void 获取所有有逻辑的被解释词(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        List<String> 所有有逻辑的被解释词=Util.获取所有有逻辑的被解释词();

        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(所有有逻辑的被解释词)).setGuanxi(常量.是));
    }

    public void 查询唯一区别教学语句(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 上一步结果=Util.获取最新成分属性(常量.上一步结果);
        List<String> list=JSON.parseArray(上一步结果,String.class);
        String 当前输入句子=Util.获取最新成分属性(常量.当前输入句子);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(两句子的唯一区别判断.获取唯一区别教学语句(list,当前输入句子)).setGuanxi(常量.是));
    }

    public void 获取当前输入句子(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(Util.获取最新成分属性(常量.当前输入句子)).setGuanxi(常量.是));
    }

    public void 替换逻辑集合中的变量(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 原句=Util.获取最新成分属性(常量.上一步结果);
        String 当前句=Util.获取最新成分属性(常量.当前输入句子);
        if(StringUtils.isNotEmpty(原句)&&StringUtils.isNotEmpty(当前句)){
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(替换逻辑集合中的变量.获取新的逻辑集合(原句,当前句))).setGuanxi(常量.是));
        }
    }

    public void 保存自动生成的逻辑集合(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 当前句=Util.获取最新成分属性(常量.当前输入句子);
        List<String> 新逻辑集合=JSON.parseArray(Util.获取最新成分属性(常量.上一步结果),String.class);
        替换逻辑集合中的变量.保存生成的逻辑集合(当前句,新逻辑集合);
    }

    public void 获取成分集合中所有单词(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        List<String> wordlist=两句子的唯一区别判断.获取成分集合中所有单词();
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(wordlist)).setGuanxi(常量.是));
    }

    public void 获取集合中指定元素(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        int 指标=Integer.parseInt(Util.获取最新成分属性(常量.指标));
        List<String> 集合数据=JSON.parseArray(Util.获取最新成分属性(常量.上一步结果),String.class);
        if(CollectionUtils.isNotEmpty(集合数据)){
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(集合数据.get(指标-1)).setGuanxi(常量.是));
        }
    }
    public void 获取有逻辑的待解释词(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String result=Util.获取有逻辑的待解释词(Util.获取最新成分属性(常量.上一步结果));
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(result).setGuanxi(常量.是));
    }

    public void 获取句子中的未知词(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 待处理句子=Util.获取最新成分属性(常量.待处理句子);
        List<String> 已知词=JSON.parseArray(Util.获取最新成分属性(常量.上一步结果),String.class);
        List<String> result=获取句子中的未知词.获取句子中的未知词(待处理句子,已知词);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(result)).setGuanxi(常量.是));
    }


    public void 组装句子(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 组装词1=Util.获取最新成分属性(常量.组装词1);
        String  组装词2=Util.获取最新成分属性(常量.组装词2);

        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(组装词1.concat(组装词2)).setGuanxi(常量.是));
    }

    public void 获取内部所有方法(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 所有内部方法名=JSON.toJSONString(Util.获取所有内部方法());
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(所有内部方法名).setGuanxi(常量.是));
    }

    public void 将数据加入到集合中(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        List<String> 已知词=new ArrayList();

        String 上一步结果=Util.获取最新成分属性(常量.上一步结果);
        List<String> 集合数据=JSON.parseArray(Util.获取最新成分属性(常量.集合数据),String.class);
        if(集合数据==null)集合数据=new ArrayList();
        try{
            集合数据.addAll(JSON.parseArray(上一步结果,String.class));
        }catch(Exception e){
            集合数据.add(上一步结果);
        }
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(集合数据)).setGuanxi(常量.是));
        Util.增加成分(new 成分().setRenwu(常量.集合数据).setShuxing(JSON.toJSONString(集合数据)).setGuanxi(常量.是));
    }

    public void 去重集合(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        List<String> 集合数据=JSON.parseArray(Util.获取最新成分属性(常量.上一步结果),String.class);
        if(集合数据==null)集合数据=new ArrayList<>();
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(集合数据.stream().distinct().collect(Collectors.toList()))).setGuanxi(常量.是));

    }

    public void 过滤集合() {
        if ("false".equals(Util.获取最新成分属性(常量.上一次判断结果))) return;
        List<String> 已知词 = new ArrayList<>();
        String 集合数据 = Util.获取最新成分属性(常量.集合数据);
        String 过滤条件 = Util.获取最新成分属性(常量.上一步结果);
        List<String> list = JSON.parseArray(Util.获取最新成分属性(常量.集合数据), String.class);
        List<String> newlist = list.stream().filter(m -> m != null && m.equals(过滤条件)).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(newlist)) {
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(null).setGuanxi(常量.是));
        } else {
            Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(newlist)).setGuanxi(常量.是));
        }
    }


    public void 根据元素分类过滤集合(){
        String 集合数据=Util.获取最新成分属性(常量.上一步结果);
        String 属性=Util.获取最新成分属性(常量.过滤条件);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(Util.根据元素分类过滤集合(JSON.parseArray(集合数据,String.class),属性))));
    }

    public void 递归获取关系属性(){
        String 属性=Util.获取最新成分属性(常量.属性);
        String 关系=Util.获取最新成分属性(常量.关系);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(Util.递归获取关系属性(属性,关系))));
    }

    public void 执行循环方法() throws Exception {
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        List<String> list=JSON.parseArray(Util.获取最新成分属性(常量.循环数据),String.class);
        String 循环体=Util.获取最新成分属性(常量.循环体);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(list.get(0)));
        for(int i=0;i<list.size();i++){
            循环体参数设置(Util.获取最新成分属性(常量.上一步结果),list.get(i));
            Util.增加成分(new 成分().setRenwu(常量.当前循环数据).setShuxing(list.get(i)));
            Util.反射执行指定方法(循环体);
        }
    }


    public void 执行无循环体方法() throws Exception {
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        List<String> list=JSON.parseArray(Util.获取最新成分属性(常量.循环数据),String.class);
        if(CollectionUtils.isEmpty(list)){
            return;
        }
        for(int i=0;i<list.size();i++){
            Util.增加成分(new 成分().setRenwu(常量.当前循环数据).setShuxing(list.get(i)));
            执行学习语句();
        }
    }

    public void 替换相似词形成新句子(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 待处理句子=Util.获取最新成分属性(常量.上一步结果);
        String 待处理词=Util.获取最新成分属性(常量.待处理词);
        List<String> 替换相似词形成新句子=替换句子汇总的相似成分.替换相似词形成新句子(待处理句子,待处理词);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(JSON.toJSONString(替换相似词形成新句子)));

    }


    public void 循环体参数设置(String 循环参数键1,  String 循环参数键2){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;

        String 循环参数键值1=Util.获取最新成分属性(常量.循环参数键1);
        String 循环参数键值2=Util.获取最新成分属性(常量.循环参数键2);
        Util.增加成分(new 成分().setRenwu(循环参数键值1).setShuxing(循环参数键1));
        Util.增加成分(new 成分().setRenwu(循环参数键值2).setShuxing(循环参数键2));
    }


    public void 执行学习语句() throws Exception {
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;

        String 当前循环数据=Util.获取最新成分属性(常量.当前循环数据);
        String 预处理逻辑=Util.获取待解释词(常量.当前循环数据);
        Util.执行思维集合(预处理逻辑,true);

    }
    public void 执行相加方法(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.获取当前方法中的变量(常量.被加数, 常量.加数);
        int 被加数=Integer.parseInt(Util.获取最新成分属性(常量.被加数));
        int 加数=Integer.parseInt(Util.获取待解释词(常量.加数));
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(被加数+加数+""));

    }

    public void 执行相减方法(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        int 被减数=Integer.parseInt(Util.获取最新成分属性(常量.被减数));
        int 减数=Integer.parseInt(Util.获取待解释词(常量.减数));
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing((被减数-减数)+""));

    }

    public void 执行相乘方法(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        Util.获取当前方法中的变量(常量.被乘数, 常量.乘数);
        int 被乘数=Integer.parseInt(Util.获取最新成分属性(常量.被乘数));
        int 乘数=Integer.parseInt(Util.获取待解释词(常量.乘数));
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing((被乘数*乘数)+""));

    }

    public void 执行相除方法(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        int 被除数=Integer.parseInt(Util.获取最新成分属性(常量.被除数));
        int 除数=Integer.parseInt(Util.获取待解释词(常量.除数));
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing((被除数/除数)+""));

    }

    public void 执行包含方法(){
        if("false".equals(Util.获取最新成分属性(常量.上一次判断结果)))return;
        String 被包含词=Util.获取最新成分属性(常量.被包含词);
        String 包含词=Util.获取最新成分属性(常量.包含词);
        Util.增加成分(new 成分().setRenwu(常量.上一步结果).setShuxing(被包含词.contains(包含词)+""));

    }
}

chengfen17.txt

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"你可以这样理解","sxindex":1}
{"explained":"你可以这样理解","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"意向词是疑问句子","sxindex":1}
{"explained":"你可以这样理解","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"获取意向词属性","sxindex":1}
{"explained":"你可以这样理解","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"意向词是被删除句子","sxindex":1}
{"explained":"你可以这样理解","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"保存意向词的值","sxindex":1}
{"explained":"你可以这样理解","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"删除词是是什么","sxindex":1}
{"explained":"你可以这样理解","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"删除句子中的词","sxindex":1}
{"explained":"你可以这样理解","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"意向词是待解释词","sxindex":1}
{"explained":"你可以这样理解"  ,"guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"保存意向词的值","sxindex":1}
{"explained":"你可以这样理解","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"你待解释词是获取有逻辑的待解释词","sxindex":1}
{"explained":"获取有逻辑的待解释词","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"获取当前输入句子","sxindex":1}
{"explained":"获取有逻辑的待解释词","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"获取有逻辑的待解释词","sxindex":1}
{"explained":"获取有逻辑的待解释词","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}
{"explained":"获取有逻辑的待解释词","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"获取当前输入句子","sxindex":1}
{"guanxi":"是","renwu":"获取有逻辑的待解释词","rwindex":1,"shuxing":"预处理逻辑","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"待解释词是对句子做相似处理","sxindex":1}
{"explained":"对句子做相似处理","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"获取当前句子","sxindex":1}
{"explained":"对句子做相似处理","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待处理词是相似","sxindex":1}
{"explained":"对句子做相似处理","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"替换相似词形成新句子","sxindex":1}

{"explained":"对句子做相似处理","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"意向词是循环数据","sxindex":1}
{"explained":"对句子做相似处理","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"保存意向词的值","sxindex":1}
{"explained":"对句子做相似处理","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"执行无循环体方法","sxindex":1}

{"explained":"对句子做相似处理","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"对句子做相似处理","rwindex":1,"shuxing":"预处理逻辑","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"意向词是疑问句子","sxindex":1}
{"explained":"意向词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"意向词是疑问句子","sxindex":1}
{"explained":"意向词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}


{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"下标是1","sxindex":1}
{"explained":"下标是1","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"下标是1","sxindex":1}
{"explained":"下标是1","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"对上一步结果取反","sxindex":1}
{"explained":"对上一步结果取反","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"否则","sxindex":1}
{"explained":"对上一步结果取反","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"分割词是疑问句子","sxindex":1}
{"explained":"分割词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"分割词是疑问句子","sxindex":1}
{"explained":"分割词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"分割个数是1","sxindex":1}
{"explained":"分割个数是1","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"分割词个数是1","sxindex":1}
{"explained":"分割个数是1","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"被包含词是43","sxindex":1}
{"explained":"被包含词是43","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"被包含词是43","sxindex":1}
{"explained":"被包含词是43","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"包含词是4","sxindex":1}
{"explained":"包含词是4","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"包含词是4","sxindex":1}
{"explained":"包含词是4","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"被分割词是疑问句子","sxindex":1}
{"explained":"被分割词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"被分割词是疑问句子","sxindex":1}
{"explained":"被分割词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"意向词是疑问句子","sxindex":1}
{"explained":"意向词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"意向词是疑问句子","sxindex":1}
{"explained":"意向词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"分割词是疑问句子","sxindex":1}
{"explained":"分割词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"分割词是疑问句子","sxindex":1}
{"explained":"分割词是疑问句子","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}


{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"对句子做相似处理是预处理逻辑","sxindex":1}
{"explained":"对句子做相似处理是预处理逻辑","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"对句子做相似处理是预处理逻辑","sxindex":1}
{"explained":"对句子做相似处理是预处理逻辑","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"查询所有被解释词的值","sxindex":1}
{"explained":"查询所有被解释词的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"要查询的字段是explained","sxindex":1}
{"explained":"查询所有被解释词的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"查询字段所有值","sxindex":1}
{"explained":"查询所有被解释词的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"筛选集合中相同个数大于2的值","sxindex":1}
{"explained":"筛选集合中相同个数大于2的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"意向词是集合数据","sxindex":1}
{"explained":"筛选集合中相同个数大于2的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"保存意向词的值","sxindex":1}
{"explained":"筛选集合中相同个数大于2的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"对集合数据分组","sxindex":1}
{"explained":"筛选集合中相同个数大于2的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"指标是2","sxindex":1}
{"explained":"筛选集合中相同个数大于2的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"过滤大于指标的分组集合","sxindex":1}
{"explained":"筛选集合中相同个数大于2的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"意向词是集合数据","sxindex":1}
{"explained":"筛选集合中相同个数大于2的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"获取意向词属性","sxindex":1}
{"explained":"筛选集合中相同个数大于2的值","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}

{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"获取所有教学语句","sxindex":1}
{"explained":"获取所有教学语句","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"查询所有被解释词的值","sxindex":1}
{"explained":"获取所有教学语句","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"筛选集合中相同个数大于2的值","sxindex":1}
{"explained":"获取所有教学语句","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}


{"guanxi":"是","renwu":"待解释词","rwindex":1,"shuxing":"获取唯一区别教学语句","sxindex":1}
{"explained":"获取唯一区别教学语句","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"获取所有有逻辑的被解释词","sxindex":1}
{"explained":"获取唯一区别教学语句","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"查询唯一区别教学语句","sxindex":1}
{"explained":"获取唯一区别教学语句","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"替换逻辑集合中的变量","sxindex":1}
{"explained":"获取唯一区别教学语句","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"保存自动生成的逻辑集合","sxindex":1}
{"explained":"获取唯一区别教学语句","guanxi":"是","renwu":"当前句子","rwindex":1,"shuxing":"待解释词是空","sxindex":1}


{"guanxi":"是","renwu":"获取唯一区别教学语句","rwindex":1,"shuxing":"预处理逻辑","sxindex":1}

{"guanxi":"前面","renwu":"获取有逻辑的待解释词","rwindex":1,"shuxing":"对句子做相似处理","sxindex":1}

{"guanxi":"前面","renwu":"对句子做相似处理","rwindex":1,"shuxing":"获取唯一区别教学语句","sxindex":1}

文件2

判断44是否包含5
    --你可以这样理解
被包含词是44
包含词是5
执行包含方法
如果正确
输出包含
否则
输出不包含
待解释词是空

输出包含
获取当前输入句子
执行输出方法
输出上一步结果
待解释词是空


输出不包含
获取当前输入句子
执行输出方法
输出上一步结果
待解释词是空

否则输出不包含
对上一步结果取反
输出不包含
待解释词是空

老马识途2.0

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【无标题】

1,创建普通maven工程pom.xml<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://m
复制链接

扫一扫