将变量和整数作为用户输入

Question

我正在考虑这个问题，并想知道字符串和整数是否可能在同一输入行上。 例如，用户输入“A = 2”，“B = 3”和“C = A + B”，C等于5.如果是，我必须知道什么类型的技术？ 我需要查一下什么？

Answer 1

一个好的起点是HashMap和String.split 。

你可能会尝试这样的事情：

// In main function
HashMap<String, Integer> map = new HashMap<String, Integer>();
for (String arg : args) {
    String[] split = arg.split(Pattern.quote("="));
    if (split.length > 1) {
        // It had an equals sign.
        String var = split[0], value = split[1];
        map.put(var, Integer.parseInt(value));
        System.out.println(var + " is now " + value); 
    }
}

这不会占A+B ，但我会将其作为一个谜题留给你。

提示 ： map.containsKey ， map.get 。

---

编辑

回答你的问题：

for (int i=0; i<args.length; i++) {
    String arg = args[i];
    // do something with arg
}

是相同的

for (String arg : args) {
    // do something with arg
}

后者被称为“for-each”或“for-in”。 args变量包含命令行参数。 我假设这个代码在main方法中，它应该有一个public static void main( String[] args )的方法签名。

put方法将键/值对添加到HashMap。 基本上，hashmap是值到键的关联（映射）。 每个键有一个值，并put重写，所以如果你运行

map.put("a", 1);
map.put("b", 2);
map.put("a", 3);

那么以下陈述是正确的：

map.get("a") == 3
map.get("b") == 2
map.get("c") == null
map.get("asdf") == null

有关更多信息，请查看地图教程 。

Answer 2

如果您正在尝试检测命令行参数，那么我会考虑这样的方法：

首先，您需要确保用户实际输入了一些参数：

public static void main(String[] args)
{
     if(args.length > 0)
     {
          //Check each set of arguments.
     }
     else
     {
          System.out.println("Invalid number of arguments");
          System.exit(1);
          // Here you can either do a try-catch and throw an exception or just simply exit if the user doesn't input the `enter code here`correct number of arguments. 
     }
}

棘手的部分将是确定用户是否输入A或B或C，这将导致一些解析。 但是你需要通过告诉用户使用格式或搜索字符串来知道输入String的位置。

假设您让用户使用以下方法输入参数：

[program] A=2 B=3 C=A+B

由于WChargin指出args是空格分隔的，这让我不知所措，我决定将每组参数分解为自己的字符串数组。 对于A和BI，使用字符“=”将分隔符拆分为字符串，如下所示：

if(args[i].toUpperCase().startsWith("A"))   
{
     resultA = args[i].split("=");  //Split by the delimter "="
     a = Double.parseDouble(resultA[1]);
}

对于A和B，将产生数组{A，2}，{B，3}。 CI将分裂两次。 首先是字符“=”，它将产生{C，A + B}，然后分割每个字符串，这将产生{，A，+，B}。 请注意，split（）在resultC [0]中生成一个空字符串，因此我们开始迭代为1。

我们将简单地检查args的长度，并迭代查找参数值：

public static void main(String[] args)
{
    double a = 0;
    double b = 0; 
    double c = 0;
    String[] resultA = null;
    String[] resultB = null;
    String[] resultC = null;
    String[] result = null;

    if(args.length > 0)
    {
        for(int i=0; i < args.length; i++)
        {   
            if(args[i].toUpperCase().startsWith("A"))   // Implemented startsWith() thanks to WChargin
            {
                resultA = args[i].split("=");   //Split by the delimter "="
                a = Double.parseDouble(resultA[1]);
            }
            else if(args[i].toUpperCase().startsWith("B"))
            {
                resultB = args[i].split("=");
                b = Double.parseDouble(resultB[1]);
            }
            else if(args[i].toUpperCase().startsWith("C"))
            {
                result = args[i].split("="); //We don't need C, split all of the arguments
                resultC = result[1].split(""); //This way we have an array of strings for each value to iterate through
                // The only problem with split("") is that we will get an empty string at the beginning of the array

                for(int j=1; j < resultC.length; j++)
                {
                    if(resultC[j].toUpperCase().startsWith("A"))
                    {
                        if(resultC[j+1].equals("+"))
                        {
                            if(resultC[j+2].toUpperCase().startsWith("A"))
                            {
                                c = a + a;
                                break;
                                // Once we get out answer, break otherwise we'll get a ArrayIndexOutOfBoundsException because the program will continue iterating
                            }
                            else if(resultC[j+2].toUpperCase().startsWith("B"))
                            {
                                c = a + b;
                                break;
                            }
                            else
                            {
                                System.out.println("Argument parse error");
                            }
                        }
                        else if(resultC[j+1].equals("-"))
                        {
                            if(resultC[j+2].toUpperCase().startsWith("A"))
                            {
                                c = a - a;
                                break;
                            }
                            else if(resultC[j+2].toUpperCase().startsWith("B"))
                            {
                                c = a - b;
                                break;
                            }
                            else
                            {
                                System.out.println("Argument parse error");
                            }
                        }
                        else if(resultC[j+1].equals("*"))
                        {
                            if(resultC[j+2].toUpperCase().startsWith("A"))
                            {
                                c = a * a;
                                break;
                            }
                            else if(resultC[j+2].toUpperCase().startsWith("B"))
                            {
                                c = a * b;
                                break;
                            }
                            else
                            {
                                System.out.println("Argument parse error");
                            }
                        }
                        else if(resultC[j+1].equals("/"))
                        {
                            if(resultC[j+2].toUpperCase().startsWith("A"))
                            {
                                c = a / a;
                                break;
                            }
                            else if(resultC[j+2].toUpperCase().startsWith("B"))
                            {
                                c = a / b;
                            }
                            else
                            {
                                System.out.println("Argument parse error");
                            }
                        }
                    }
                    else if(resultC[j].toUpperCase().startsWith("B"))
                    {
                        if(resultC[j+1].equals("+"))
                        {
                            if(resultC[j+2].toUpperCase().startsWith("A"))
                            {
                                c = b + a;
                                break;
                            }
                            else if(resultC[j+2].toUpperCase().startsWith("B"))
                            {
                                c = b + b;
                                break;
                            }
                            else
                            {
                                System.out.println("Argument parse error");
                            }
                        }
                        else if(resultC[j+1].equals("-"))
                        {
                            if(resultC[j+2].toUpperCase().startsWith("A"))
                            {
                                c = b - a;
                                break;
                            }
                            else if(resultC[j+2].toUpperCase().startsWith("B"))
                            {
                                c = b - b;
                                break;
                            }
                            else
                            {
                                System.out.println("Argument parse error");
                            }
                        }
                        else if(resultC[j+1].equals("*"))
                        {
                            if(resultC[j+2].toUpperCase().startsWith("A"))
                            {
                                c = b * a;
                                break;
                            }
                            else if(resultC[j+2].toUpperCase().startsWith("B"))
                            {
                                c = b * b;
                                break;
                            }
                            else
                            {
                                System.out.println("Argument parse error");
                            }
                        }
                        else if(resultC[j+1].equals("/"))
                        {
                            if(resultC[j+2].toUpperCase().startsWith("A"))
                            {
                                c = b / a;
                                break;
                            }
                            else if(resultC[j+2].toUpperCase().startsWith("B"))
                            {
                                c = b / b;
                                break;
                            }
                            else
                            {
                                System.out.println("Argument parse error");
                            }
                        }
                    }
                    else
                    {
                        System.out.println("Argument error in C");
                        System.exit(1);
                    }
                }
            }
        }
    }
    else
    {
        System.out.println("Invalid number of arguments");
        System.exit(1);
    }

    System.out.printf("A: %f\nB: %f\nC: %f\n", a, b, c);
}

请注意我可能没有考虑所有可能性。

通过命令行参数解析肯定更简单。 我给你的方法太长了。

我希望这可以帮助你！

Answer 3

首先你必须进行字符串匹配。 其中背面'='的位置编号为'2'，前面的位置字符串'='为'A'，并将字符串'A'保存到数字索引数组中，并将数字'2'保存到值索引数组中A.那么技术使用B = 2就像那样。 你用字符串匹配检测到的最后一个。 在背面和正面操作符上，例如'='是'A'和'B'。 并将index的数组与此字符串相同。 和总和。 然后将和值保存到变量字符串C中，就像保存变量A和B一样

Answer 4

如果您使用Java 6+，则脚本非常有用：

public static void main(String[] args) {
    try {
        ScriptEngineManager mgr = new ScriptEngineManager();
        ScriptEngine scripEngine = mgr.getEngineByExtension("js");

        scripEngine.eval("A=2; B=3; C=A+B");

        System.out.println("" + scripEngine.get("A") + "+" + scripEngine.get("B") + "=" + scripEngine.get("C"));
    } catch (ScriptException e) {
        e.printStackTrace();
    }
}

输出：2.0 + 3.0 = 5.0