Command line arguments are aggregated into an String[] in Java and passed into your main un-processed.

public static void main(final String[] args) { // code }

With your example input of D:/input a.conf,b.conf,c.conf D:/output the value of args becomes ["D:/input", "a.conf,b.conf,c.conf", "D:/output"] where the [] delimit an array of String.

You have two options:

1. manually parse this args array and pull it apart manually and process each element yourself. In this case you need to Arrays.asList(args[2].split(",")); the second argument to get it into a List<String> as you desire.
2. Use something like JSAP ( Java Simple Argument Parser ) and let a well tested and mature library parse, validate and format the input for you. Specifically it can parse the second argument you are passing in for you.

Needless to say, I prefer the second option because the first is just brittle busy work.

Use the Apache Commons CLI library commandline.getArgs() to get arg1, arg2, arg3, and arg4. Here is some code:

    import org.apache.commons.cli.CommandLine;
    import org.apache.commons.cli.Option;
    import org.apache.commons.cli.Options;
    import org.apache.commons.cli.Option.Builder;
    import org.apache.commons.cli.CommandLineParser;
    import org.apache.commons.cli.DefaultParser;
    import org.apache.commons.cli.ParseException;

    public static void main(String[] parameters)
    {
        CommandLine commandLine;
        Option option_A = Option.builder("A")
            .required(true)
            .desc("The A option")
            .longOpt("opt3")
            .build();
        Option option_r = Option.builder("r")
            .required(true)
            .desc("The r option")
            .longOpt("opt1")
            .build();
        Option option_S = Option.builder("S")
            .required(true)
            .desc("The S option")
            .longOpt("opt2")
            .build();
        Option option_test = Option.builder()
            .required(true)
            .desc("The test option")
            .longOpt("test")
            .build();
        Options options = new Options();
        CommandLineParser parser = new DefaultParser();

        String[] testArgs =
        { "-r", "opt1", "-S", "opt2", "arg1", "arg2",
          "arg3", "arg4", "--test", "-A", "opt3", };

        options.addOption(option_A);
        options.addOption(option_r);
        options.addOption(option_S);
        options.addOption(option_test);

        try
        {
            commandLine = parser.parse(options, testArgs);

            if (commandLine.hasOption("A"))
            {
                System.out.print("Option A is present.  The value is: ");
                System.out.println(commandLine.getOptionValue("A"));
            }

            if (commandLine.hasOption("r"))
            {
                System.out.print("Option r is present.  The value is: ");
                System.out.println(commandLine.getOptionValue("r"));
            }

            if (commandLine.hasOption("S"))
            {
                System.out.print("Option S is present.  The value is: ");
                System.out.println(commandLine.getOptionValue("S"));
            }

            if (commandLine.hasOption("test"))
            {
                System.out.println("Option test is present.  This is a flag option.");
            }

            {
                String[] remainder = commandLine.getArgs();
                System.out.print("Remaining arguments: ");
                for (String argument : remainder)
                {
                    System.out.print(argument);
                    System.out.print(" ");
                }

                System.out.println();
            }

        }
        catch (ParseException exception)
        {
            System.out.print("Parse error: ");
            System.out.println(exception.getMessage());
        }
    }

How to pass args to main() in command line in Java?

First, your command line is incorrect.

Copy$ java -Dlog4j.configuration=logging.properties -classpath ${class_path} \
       --year="2021" --month="2" --day="2" --customerId=1234567

should be

Copy$ java -Dlog4j.configuration=logging.properties -classpath ${class_path} \
       ${class_name} --year="2021" --month="2" --day="2" --customerId=1234567

where ${class_name} is the full name of the class containing your entry point method; e.g. com.acme.myapp.Main or something. See https://stackoverflow.com/a/18093929/139985 for more details.

Once you have corrected the above, the args will be delivered in the args parameter as a value equivalent to:

Copynew String[]{"--year=2021", "--month=2", "--day=2", "--customerId=1234567"}

Notice that the shell will have removed the original quotes. (If you want to stop that then they need to be quoted or escaped on command line. It happens before Java even sees the arguments.)

It is now your problem to turn those strings into something that your program can understand. There are two approaches:

• Implement the argument parsing in custom Java code; e.g. using String.split, Integer.parseInt and so on.

• Find and use Java command line parser library. A Google search for java command line parser will give you a lot of candidates.

If you want to conform to an existing set of conventions (e.g. https://www.gnu.org/prep/standards/html_node/Command_002dLine-Interfaces.html), look for a library that handles this.

(Note that the standard Java SE libraries don't include command line argument parsing functionality. I guess the reason is OS command line argument conventions are sufficiently diverse that a usable portable solution is not feasible.)