Java 自定义方程解算器错误

我在让我的自定义方程式计算器工作时遇到了一些困难。我给它传递一个从文本文件中读取的字符串（除了字符串之间没有空格）以及一个等式，并给它传递一个关键字映射，这些关键字链接到它们所表示的值。我已经测试过了，我所有的地图都正常工作。下面是我处理结果的尝试，不管结果是int还是字符串。这将是仅有的两种允许的条目类型。方程的每一侧可以有一个或两个元素，用加号或减号分隔。仅允许三个运算符对两侧进行评估，它们是，=。边只能有关键字或整数，所以不能有灵巧度+1=强度+2这样的东西

当我尝试编译此类时，当前遇到的错误是“找不到适合parseint的方法”“方法整数。parseint（字符串，int）不适用”。如果我没有弄错的话，因为我是直接编译这个类，而不是主类，那么它甚至没有地图来进行这种判断调用。这是个问题吗？我以这种方式编译是因为我遇到了这样的问题：重新编译主类没有重新编译次类文件，从而导致了问题

任何示例公式：灵巧度>3或背景=退伍军人

import java.lang.String;
import java.util.HashMap;
import java.util.Map;

public class Equation {
private String[] sides = new String[2];
private String[] rawEquation = new String[3];
private String[] parts = new String[2];
private String type;
private int[] tempInt = new int[2];
private int[] finalSide = new int[2];
private String[] finalStride = new String[2];

public boolean solve(String equation, Map gladMap) {
    if (equation.indexOf("<") > -1) {
        sides = equation.split("<");
        rawEquation[1] = "<";   
    } else if (equation.indexOf(">") > -1) {
        sides = equation.split(">");
        rawEquation[1] = ">";
    } else if (equation.indexOf("=") > -1) {
        sides = equation.split("=");
        rawEquation[1] = "=";
    }
    rawEquation[0] = sides[0];
    rawEquation[2] = sides[1];
    for (int d = 0; d < 2; d++) {
        if (sides[d].indexOf("+") > -1) {
            parts = rawEquation[0].split("\\+");
            for (int a = 0; a < 2; a++) {
                if (isInteger(parts[a])){
                    tempInt[a] = Integer.parseInt(parts[a]);
                } else {
                    tempInt[a] = Integer.parseInt(gladMap.get(parts[a]));               
                }
            }       
            finalSide[d] = tempInt[0]+tempInt[1];
            type = "Int";   
        } else if (rawEquation[0].indexOf("-") > -1) {
            parts = rawEquation[0].split("\\-");
            for (int a = 0; a < 2; a++) {
                if (isInteger(parts[a])){
                    tempInt[a] = Integer.parseInt(parts[a]);        
                } else {
                    tempInt[a] = Integer.parseInt(gladMap.get(parts[a]));       
                }
            }       
            finalSide[d] = tempInt[0]-tempInt[1];
            type = "Int";   
        } else {
            if (isInteger(sides[0])){
                finalSide[d] = Integer.parseInt(sides[0]);      
            } else {
                if (isInteger(gladMap.get(sides[0]))) {
                    finalSide[d] = Integer.parseInt(gladMap.get(sides[0])); 
                    type = "Int";
                } else {
                finalStride[d] = gladMap.get(sides[0]);
                type = "Str";
                }
            }       


        }
    }
    if (rawEquation[1].equals("<")) {
        if (type.equals("Int")) {
            if (finalSide[0] < finalSide[1]) {
                return true;
            }
        } 
    } else if (rawEquation[1].equals(">")) {
        if (type.equals("Int")) {
            if (finalSide[0] > finalSide[1]) {
                return true;
            }
        } 
    } else {
        if (type.equals("Int")) {
            if (finalSide[0] == finalSide[1]) {
                return true;
            }
        } else if (type.equals("Str")) {
            if (finalStride[0].equals(finalStride[1])) {
                return true;
            }
        }   
    }

return false;
} 
public boolean isInteger( String input ) {
    try {
        Integer.parseInt( input );
        return true;
    }
    catch( Exception NumberFormatException ) {
        return false;
    }
}   




}

import java.lang.String；
导入java.util.HashMap；
导入java.util.Map；
公共阶级方程式{
私有字符串[]边=新字符串[2]；
私有字符串[]rawEquation=新字符串[3]；
私有字符串[]部分=新字符串[2]；
私有字符串类型；
私有整数[]临时整数=新整数[2]；
私有int[]finalSide=新int[2]；
私有字符串[]finalStride=新字符串[2]；
公共布尔解算（字符串方程、映射、映射）{
if（方程式indexOf（“”）；
方程[1]=“>”；
}else if（方程式indexOf（“=”>-1）{
边=方程式。拆分（“=”）；
方程[1]=“=”；
}
方程[0]=边[0]；
方程[2]=边[1]；
对于（int d=0；d<2；d++）{
if（边[d].indexOf（“+”>-1）{
parts=rawEquation[0]。拆分（“\\+”）；
对于（int a=0；a<2；a++）{
if（isInteger（第[a]部分）{
tempInt[a]=Integer.parseInt（部分[a]）；
}否则{
tempInt[a]=Integer.parseInt（gladMap.get（parts[a]）；
}
}       
最后一方[d]=tempInt[0]+tempInt[1]；
type=“Int”；
}else if（方程式[0]。索引of（“-”>-1）{
parts=rawEquation[0]。拆分（“\\-”）；
对于（int a=0；a<2；a++）{
if（isInteger（第[a]部分）{
tempInt[a]=Integer.parseInt（部分[a]）；
}否则{
tempInt[a]=Integer.parseInt（gladMap.get（parts[a]）；
}
}       
finalSide[d]=tempInt[0]-tempInt[1]；
type=“Int”；
}否则{
if（isInteger（边[0]））{
finalSide[d]=Integer.parseInt（边[0]）；
}否则{
if（isInteger（gladMap.get（边[0]））{
finalSide[d]=Integer.parseInt（gladMap.get（sides[0]）；
type=“Int”；
}否则{
finalStride[d]=gladMap.get（边[0]）；
type=“Str”；
}
}       
}
}
if（方程式[1]。等于（“”）{
if（type.equals（“Int”））{
if（最终定义[0]>最终定义[1]）{
返回true；
}
} 
}否则{
if（type.equals（“Int”））{
if（最终数据集[0]==最终数据集[1]）{
返回true；
}
}else if（type.equals（“Str”））{
如果（finalStride[0]。等于（finalStride[1]））{
返回true；
}
}   
}
返回false；
} 
公共布尔isInteger（字符串输入）{
试一试{
整数.parseInt（输入）；
返回true；
}
捕获（异常编号格式异常）{
返回false；
}
}   
}

---

我试图通过创建一个临时字符串变量将Integer.parseInt（）从gladMap.get（sides[0]）中分离出来，但它没有改变任何东西。希望您能提供任何帮助！

这里，您传递的映射不是泛型类型。因此，get（）将始终返回一个对象，这不是parseInt（）的合适参数方法。 将方法签名更改为 公共布尔解算（字符串方程，映射gladMap）{

---

应该解决错误。

问题可能如下：您的映射没有类型化，因此调用像

gladMap.get（sides[0]）

返回对象。

Integer.parseInt

需要字符串。您可以将其更改为

gladMap.get（边[0]）.toString（）

---

它认为它应该工作。如果值是实际字符串，那么

toString

将返回它自己，它是

Integer

它将转换为字符串并解析回来。

非常好。我仍然在理解关于何时何地应该使用泛型类型和特定类型的概念时遇到一些困难。将标记为answe几分钟后出现红色。Java版本5中添加了泛型。泛型用于保持集合的一致性以及编译时的安全性。它们的设计旨在防止方法在集合中填充任何作为参数传递给它的内容。以下博客提供了关于何时使用泛型的良好理解：