Java 如何以任意顺序给出命令行参数？

我有两个枚举，一个用于应用程序，一个用于环境。我希望能够以任意顺序给出这些参数，因此我可以给出-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);

---

对于（int i=0；i它可以简单得多：

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

boolean isApp=false；
布尔isEnv=false；
对于（int i=0；i来说，自己实现这一点非常简单。使用前导的
-
作为指示符。

试试这个代码。我想这就是你想要的。这个解决方案也非常通用，

即使您稍后添加其他参数类型（不仅仅是
-app
和
-env
），它也可以工作

上周有人给了你这个问题的另一个版本的答案，你已经问了三四次了，这正是你想要的。我现在找不到它（它可能已被删除），但它基本上是以下代码：

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

publicstaticvoidmain（字符串[]args）{
列表应用程序=新建ArrayList（）；
List envs=new ArrayList（）；
列表目的地=null；
for（字符串arg:args）{
如果（“-app.”等于（arg））{
目的地=应用程序；
}如果（“-env”.equals（arg））{
目的地=环境；
}else if（destination==null）{
System.out.printf（“无效参数：%s%n”，arg）；
}否则{
目的地。添加（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);
}

publicstaticvoidmain（字符串[]args）{
列表应用程序=新建ArrayList（）；
List envs=new ArrayList（）；
布尔appFlag=false；
布尔envFlag=false；
for（字符串arg:args）{
如果（“-app.”等于（arg））{
appFlag=true；
envFlag=false；
}如果（“-env”.equals（arg））{
envFlag=true；
appFlag=false；
}else if（appFlag）{
apps.add（Application.valueOf（arg））；
}else if（环境标志）{
环境添加（环境值（arg））；
}否则{
System.out.printf（“无效参数：%s%n”，arg）；
}
}
应用程序。选择应用程序测试（应用程序、环境）；
}
以下是我应该做的：

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

}

地图也会有这个键值对

以下内容也将起作用：

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>

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

-环境环境1-应用程序app1-环境环境2-应用程序app2

如果您不想让上述方法起作用，请检查main方法中的键是否重复。希望答案有帮助。
此解决方案是可扩展的，因为它没有进行共享编码：

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>

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

为什么不使用库呢？JOpt、Commons CLI、JCommander、Args4j……这些库中的大多数都可以提供您所需要的现成功能。我发现了一个相当长的命令行参数解析器列表：@RobbyCornelissen我的经理告诉我（我只是一名实习生）通常使用库会更好，但现在使用它会使运行库变得更复杂。我知道这听起来很愚蠢，但我应该在这里重新发明方向盘。我没有忽视它们。显然，它们并不像我也需要它们那样工作。我保证我试过人们给我的东西，我试着调整它们以满足我的需要。我我被问到关于拆分字符串的问题，因为这是我最初被要求做这项任务的方式。如果你能从一开始就这样帮助我，那就不会是一个问题。谢谢。