如何通过在Java中递归串联串联来生成方程

Question

试图通过递归串联的字符串来实现数学方程生成，该字符串由类包含与子节点相同的类返回的类。最终方程式包含重复的变量，我想弄清楚如何在这种情况下结束递归。

我有一个class1，其中包含同一class1对象的集合/列表。class1还包含class2和class3对象的集合/列表。现在穿越父级，我需要以层次结构的方式从所有孩子和父对象中生成一个表达式。对于例如：exp1(class1(包含exp2(class1(，操作员(class3(和属性(class2(。现在必须通过class1之类的对象树生成一个长的表达，class2在中间的方程式和操作员的左侧和右侧。

public Map<String,String> generatecode(Map<String,String> Codes) {
    String code = Codes.get("code");
    String exit = Codes.get("exit");
    String operator = "";
    String operand1 = "";
    String operand2 = "";
    Set<Class2> attrs = getAttributes();
    Set<Class1> exps = getExpressions();
    if(attrs.size()>=2)
        exit="1";
    Iterator<Class2> itr = attrs.iterator();
    while (itr.hasNext()) {
        class2 attr=itr.next();
        if(attr.getProperty("operand").equals("operand1")) {
            operand1= attr.getName();
        }
        else if(attr.getProperty("operand").equals("operand2")) {
            operand2= attr.getName();
        }
    }
    if(!exit.equals("1") & exps!=null & !exps.isEmpty()) {
            Iterator<Class1> itr = exps.iterator();
            while (itr.hasNext()) {
                Class1 exp=itr.next();
                if(exp.getProperty("operand").equals("operand1")) {
                    Map<String,String> result=exp.generatecode(Map.of("code",code,"exit",exit));
                    exit=result.get("exit");
                    if(!operand1.contains(result.get("code")))
                    operand1+= result.get("code");
                }
                if(exp.getProperty("operand").equals("operand2")) {
                    Map<String,String> result=exp.generatecode(Map.of("code",code,"exit",exit));
                    exit=result.get("exit");
                    if(!operand2.contains(result.get("code")))
                    operand2+= result.get("code");
                }
            }
    }
    code += operand1+operator+operand2; 
    if(!exit.equals("1"))
        code="";
    return Map.of("code",code,"exit",exit);
}

主类包含

    Class1 aw_plus_w = new Class1();
    Class3 waw_plus = new Class3("+");
    aw_plus_w.addClass2(aw, Map.of("operand", "operand2"));
    aw_plus_w.addClass2(w, Map.of("operand", "operand1"));
    aw_plus_w.addOperator(waw_plus);
    Class1 c_minus_w = new Class1();
    Class3 cw_minus = new Class3("-");
    c_minus_w.addClass2(c, Map.of("operand", "operand2"));
    c_minus_w.addClass1(aw_plus_w, Map.of("operand", "operand1"));
    c_minus_w.addOperator(cw_minus);
    Class1 fr_div_size = new Class1();
    Class3 fr_div = new Class3("/");
    fr_div_size.addClass1(c_minus_w, Map.of("operand", "operand1"));
    fr_div_size.addClass2(size, Map.of("operand", "operand2"));
    fr_div_size.addOperator(fr_div);
    String code="";
    fr_div_size.generatecode(Map.of("code",code,"exit","0");

预期结果：( AW W(-c(/size 但实际结果：(((w aw-c-c(/(size((/(size(((

我尝试了三天，找不到出路。这里出了什么问题？如果有人可以指出错误

，这将是感谢的

更新的示例代码：

import java.util.HashSet;
import java.util.Set;
public class MyClass {
    abstract class Node
{
    public abstract String getCode();
//    public abstract boolean isAttribute();
}
public class Attribute extends Node
{
    private String name;
    public Attribute(String name)
    {
        this.name=name;
    }
    public String getCode()
    {
        return name;
    }
}
public class Expression extends Node
{
    private String name;
    private Set<Attribute> arg1 = new HashSet<Attribute>();
    private Set<Expression> arg2 = new HashSet<Expression>();
    private String op;
    public Expression(Set<Attribute> arg1,Set<Expression> arg2, String op)
    {
        this.arg1=arg1;
        this.arg2=arg2;
        this.op=" "+op+" ";
    }
    public String getCode()
    {
        String result="";
        // The correct code need to be written here
        return result;
    }
    public Expression(String name)
    {
        this.name=name;
    }
}
    public static void main(String args[]) {
        MyClass cl=new MyClass();
        cl.run();
    }
    public void run(){
        Attribute x=new Attribute("x");
        Expression xpx=new Expression(Set.of(x,x),null,"+");
        Expression xpxdx=new Expression(Set.of(x),Set.of(xpx),"/");
        System.out.println(xpxdx.getCode());
    }
}

Answer 1

我还没有找到您获得的律师的原因。我怀疑它是在您未显示的代码中出现的。(例如，代码中的任何内容都不会产生"("one_answers"(字符(。

可能有一个错误，但在最高级别您设置exit =" 1"，然后将其一直向下传递。

您使用地图传递参数会使您的代码更难读取的读取比需要的更难。

您还应该研究多态性以载入负载。

如果我正确理解您的问题，则以下是一个简单的实现；(类的嵌套是因为我正在使用的在线小提琴不允许多个文件，因此适当的实现应在单独的文件中具有单独的类。(

public class MyClass {
    abstract class Expression
{
    public abstract String getCode();
    public abstract boolean isLiteral();
}
public class Literal extends Expression
{
    private String name;
    public Literal(String name)
    {
        this.name=name;
    }
    public String getCode()
    {
        return name;
    }
    public boolean isLiteral()
    {
        return true;
    }
}
public class Binary extends Expression
{
    private Expression arg1;
    private Expression arg2;
    private String op;
    public Binary(Expression arg1,Expression arg2, String op)
    {
        this.arg1=arg1;
        this.arg2=arg2;
        this.op=" "+op+" ";
    }
    public String getCode()
    {
        String result="";
        if(!arg1.isLiteral()) result+="("+arg1.getCode()+")";
        else result+=arg1.getCode();
        result+=op;
        if(!arg2.isLiteral()) result+="("+arg2.getCode()+")";
        else result+=arg2.getCode();
        return result;
    }
    public boolean isLiteral()
    {
        return false;
    }
}
    public static void main(String args[]) {
        MyClass cl=new MyClass();
        cl.run();
    }
    public void run(){
        Literal x=new Literal("x");
        Expression xpx=new Binary(x,x,"+");
        Expression xpxdx=new Binary(xpx,x,"/");
        System.out.println(xpxdx.getCode());
    }
}

通过为允许的操作员进行枚举可以进一步改善。

也应该使用StringBuilder类而不是直接字符串串联。