0

私はこれについて考えていて、文字列と整数が同じ入力行にある可能性があるかどうか疑問に思っていました. たとえば、ユーザーは「A=2」、「B=3」、および「C= A+B」を入力し、C は 5 に等しいとします。そうであれば、どのようなテクニックを知っておく必要がありますか? 何を調べる必要がありますか?

4

4 に答える 4

1

コマンドライン引数を検出しようとしている場合は、次のようなアプローチを検討します。

まず、ユーザーが実際にある程度の引数を入力していることを確認する必要があります。

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を入力したかどうかを判断することであり、これにより、ある程度の解析が発生します。ただし、ユーザーに使用形式を通知するか、文字列を検索することにより、入力文字列のどこにあるかを知る必要があります。

次のメソッドを使用してパラメーターを入力するユーザーがいるとします。

[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は2回分割されます。最初に文字「=」で{C、A + B}を生成し、次に各文字列を分割して{、A、+、B}を生成します。split()はresultC [0]に空の文字列を生成するため、1から繰り返しを開始することに注意してください。

引数の長さを確認し、繰り返してパラメータ値を見つけます。

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);
}

私はおそらくすべての可能性を説明しなかったことに注意してください。

コマンドライン引数を解析する簡単な方法は間違いなくあります。私はあなたに過度に長い方法を与えています。

これがお役に立てば幸いです。

于 2012-12-02T02:55:27.327 に答える
1

開始するのに適した場所は、HashMapString.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.containsKeymap.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変数には、コマンドライン引数が含まれています。このコードはメイン メソッドにあり、メソッド シグネチャは.public static void main(String[] args)

このputメソッドは、キーと値のペアを HashMap に追加します。基本的に、ハッシュマップはキーと値の関連付け (マップ) です。各キーは 1 つの値を持つことができ、put上書きされるため、実行すると

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

その場合、次のステートメントは true です。

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

詳細については、マップのチュートリアルをご覧ください。

于 2012-12-02T02:16:22.743 に答える
0

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

于 2012-12-02T03:04:20.643 に答える
0

まず、文字列の一致を行う必要があります。裏側「=」の位置番号は「2」、表側「=」の位置文字列は「A」で、文字列「A」を数値インデックス配列に保存し、数値「2」を値インデックス配列に保存しますA. B=2 を使用するテクニックは、そのように同じです。文字列マッチングで最後に検出します。裏側と表側の演算子では、例 '=' は 'A' と 'B' です。この文字列と同じインデックスの配列を配置します。と合計値。次に、変数AとBを保存するのと同じように、合計値を変数文字列Cに保存します

于 2012-12-02T02:31:26.370 に答える