Question

我有两个枚举，一个用于应用，一个用于环境。我希望能够以任何顺序给出这些参数，所以我可以给-app app1 app1 -env env1 env2或-env env1 env2 -app app1 app2。现在我只能做第一个。我还想能够说--app app1 app2它运行我在所有环境中列出的所有应用程序，并且环境相同，但我更关心的是能够以任何顺序提供它们。

 for(int i = 0; i<args.length; i++)
            {
                if(args[i].equals("-app"))
                {
                    indexOfApp = i;
                }else if(args[i].equals("-env"))
                {
                    indexOfEnv = i;
                }
            }

            int countOfApp = -1;
            int countOfEnv = -1;

            if(indexOfApp != -1 && indexOfEnv != -1)
            {
                countOfApp = indexOfEnv - 1;
                countOfEnv = args.length - (indexOfEnv + 1);
            }


            System.out.println(countOfApp);

            System.out.println(countOfEnv);

            for(int appIndex = indexOfApp + 1; appIndex < countOfApp + 1; appIndex++){
                appList.add(args[appIndex]);

            }
                for(String item : appList )
                {
                    Application app = Application.valueOf(Application.class, item);
                    appList2.add(app);
                }
            for(int envIndex = indexOfEnv + 1; envIndex < args.length; envIndex++){
                envList.add(args[envIndex]);

            }
            for(String item : envList )
            {
             Environment env = Environment.valueOf(Environment.class, item);
                envList2.add(env);
            }

            }    System.out.println(appList); System.out.println(envList);
        Application.chooseAppTest(appList2, envList2);

Answer 1

它可以更简单：

boolean isApp = false;
boolean isEnv = false;

for (int i = 0; i<args.length; i++) {
    if (args[i].equals ("-app")) {
        isApp = true;
        isEnv = false;
    } else if (args[i].equals ("-env")) {
        isEnv = true;
        isApp = false;
    } else if (isEnv) {
        envList.add(args[i]);
    } else if (isApp) {
        appList.add(args[i]);
    }
}

Answer 2

此解决方案具有可扩展性，因为它不是硬编码的：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    // this method does all the work
    static private String[] getArgs(String argArray[],String indicator){            
        String arguments="";
        for (String s: argArray){
            arguments = arguments + s +" ";
        }
        arguments = arguments.trim();
        Pattern p = Pattern.compile(indicator+" ([^\\-]*)");    
        Matcher m = p.matcher(arguments);
        String[] newArgs={};
        try {
            m.find();
            newArgs = m.group(1).split(" ");
        } catch (IllegalStateException e){              
        }               
        return newArgs;         
    }

    public static void main (String args[]){            
        System.out.println("ENVS");
        String[] e=getArgs(args,"-env");
        for (String s: e){
            System.out.println(s);
        }           
        System.out.println("APPS");
        e=getArgs(args,"-app");
        for (String s: e){
            System.out.println(s);
        }               
    }
}

示例输出：

java Main -env env1 env2 env3 -app app1 app2
ENVS
env1
env2
APPS
app1
app2


java Main -app app1 app2 app3 app4 -env env1 env2
ENVS
env1
env2
APPS
app1
app2
app3
app4


java Main -app app1 app2
ENVS
APPS
app1
app2

Answer 3

自己实现这一点非常简单。使用前导-作为指标试试这个代码。我想这就是你想要的。这个解决方案也很普遍，
即使您稍后添加其他参数类型（不仅仅是-app和-env），它也会有效。

import java.util.HashMap;
import java.util.ArrayList;


public class Test006 {

    public static void main(String[] args) {
        System.out.println(args.length);

        HashMap<String, ArrayList<String>> mp = 
        new HashMap<String, ArrayList<String>>();

        String key = "";
        for (int i=0; i<args.length; i++){
            if (args[i].startsWith("-")){
                mp.put(args[i], new ArrayList<String>());
                key = args[i];
            }else{
                mp.get(key).add(args[i]);
            }
        }

        for (String k : mp.keySet()){
            System.out.println("---->" + k);
            for (String s : mp.get(k)){
                System.out.println("///" + s);
            }
        }
    }

}

<强>输出：

C:\Programs\eclipse\workspace\_TEST>java -cp ./bin Test006 -app a1 a2 -env e1 e2
6
---->-env
///e1
///e2
---->-app
///a1
///a2

C:\Programs\eclipse\workspace\_TEST>java -cp ./bin Test006 -env e1 e2 -app a1 a2
6
---->-env
///e1
///e2
---->-app
///a1
///a2

C:\Programs\eclipse\workspace\_TEST>

Answer 4

上周，有人给你回答了这个问题的另一个版本，你现在已经问了三四次了，这将完全符合你的要求。我现在无法找到它（它可能已被删除），但它基本上就是这段代码：

public static void main(String[] args) {
    List<String> apps = new ArrayList<>();
    List<String> envs = new ArrayList<>();
    List<String> destination = null;

    for (String arg : args) {
        if ("-app".equals(arg)) {
            destination = apps;
        } else if ("-env".equals(arg)) {
            destination = envs;
        } else if (destination == null) {
            System.out.printf("Invalid argument: %s%n", arg);
        } else {
            destination.add(arg);
        }
    }
}

我不明白为什么你忽略了这个解决方案，因为它完全符合你的要求。（当时，出于某些奇怪的原因，你问的是将字符串拆分成数组。）

你可以这样做：

public static void main(String[] args) {
    List<Application> apps = new ArrayList<>();
    List<Environment> envs = new ArrayList<>();
    boolean appFlag = false;
    boolean envFlag = false;

    for (String arg : args) {
        if ("-app".equals(arg)) {
            appFlag = true;
            envFlag = false;
        } else if ("-env".equals(arg)) {
            envFlag = true;
            appFlag = false;
        } else if (appFlag) {
            apps.add(Application.valueOf(arg));
        } else if (envFlag) {
            envs.add(Environment.valueOf(arg));
        } else {
            System.out.printf("Invalid argument: %s%n", arg);
        }
    }
    Application.chooseAppTest(apps, envs);
}

Answer 5

以下是我的所作所为：

<强> 1。创建枚举 - 您要添加的任何其他参数都应添加到此列表中

enum Args {

    ENV("-env"),

    APP("-app"),

    NONE("");

    String argCode;

    /**
     * @return the argCode
     */
    public String getArgCode() {
        return argCode;
    }

    Args(String argCode){
        this.argCode = argCode;
    }

    /**
     * @param str
     * @return
     */
    public static Args getArgs(String str){
        for (Args arg : Args.values()){
            if (arg.getArgCode().equalsIgnoreCase(str)){
                return arg;
            }
        }

        return NONE;
    }

}

<强> 2。现在有以下 - 这些行运行以准备一个参数名称为键的地图，它的值为值列表

public static void main(String[] args) {

    HashMap <String, ArrayList<String>> argMap = new HashMap<String, ArrayList<String>>();

    String argCode = null;

    for (String arg: args){
        Args a = Args.getArgs(arg);

        if (!a.equals(Args.NONE)){
            argCode = a.getArgCode();
            continue;
        }

        ArrayList<String> argList = argMap.get(argCode);

        if (argList == null){
            argList = new ArrayList<String>();

            argMap.put(argCode, argList);
        }

        argList.add(arg);
    }

    System.out.println(argMap.toString());

}

第3。以下是输出：使用地图获取值列表

{ - env = [env1，env2]， - app = [app1，app1]}

如果您在列表中添加了另一个参数，请说“-sample”只需添加到枚举列表中，如下所示：

    ENV("-env"),

    APP("-app"),

    Sample("-sample"),

    NONE("");

并且地图也将具有此键值对。

以下内容也有效：

-env env1 -app app1 -env env2 -app app2

如果您不希望上述操作，请检查main方法中键的重复。希望答案是有帮助的。

如何以任何顺序提供命令行参数？

5 个答案: