Command Line Arguments in Java

Command line arguments in Java are parameters passed to a Java program when it is executed from the command line. These arguments are stored as strings in the String[] args array of the main method, which is the entry point of every Java application. You can use these command line arguments in Java to control the behavior of your program dynamically.

Syntax of Command Line Arguments in Java

The main method in Java has the following signature:

public static void main(String[] args)

Here, args is an array of strings that holds the command line arguments passed to the program. Each argument is separated by a space.

How to Pass Command Line Arguments in Java

To pass command line arguments to a Java program, use the following syntax when running the program from the command line:

java ClassName arg1 arg2 arg3 ...

For example:

java MyProgram Hello World 123

In this example:

• MyProgram is the name of the Java class.
• Hello, World, and 123 are the command line arguments.

Accessing Command Line Arguments in Java

You can access the command line arguments using the args array in the main method. The first argument is stored in args[0], the second in args[1], and so on. The length of the args array can be determined using args.length.

Example:

public class MyProgram {
    public static void main(String[] args) {
        System.out.println("Number of arguments: " + args.length);

        for (int i = 0; i < args.length; i++) {
            System.out.println("Argument " + (i + 1) + ": " + args[i]);
        }
    }
}

If you run the program with the following command:

java MyProgram Hello World 123

The output will be:

Number of arguments: 3
Argument 1: Hello
Argument 2: World
Argument 3: 123

Best Practices for Using Command Line Arguments in Java

1. Validate Arguments: Always check the number and format of arguments to ensure they meet your program’s requirements.

if (args.length < 2) {
    System.out.println("Usage: java MyProgram <arg1> <arg2>");
    return;
}

2. Provide Usage Instructions: Display a helpful message if the user provides incorrect or insufficient arguments.

if (args.length == 0) {
    System.out.println("Usage: java MyProgram <arg1> <arg2> ...");
    return;
}

3. Convert Arguments to Appropriate Types: Command line arguments are passed as strings. Convert them to the required data types (e.g., int, double) if necessary.

int number = Integer.parseInt(args[0]);

4. Use Descriptive Argument Names: When documenting your program, use descriptive names for arguments to make their purpose clear.

// Usage: java MyProgram <username> <age>

We can also use command line arguments to pass in additional options or flags to a program. For example, we might have a program that takes a -v flag to enable verbose mode.

In this case, we could use the following command to run the program in verbose mode:

java Main -v

To check for the presence of a flag in the args array, we can use an if statement:

if (args[0].equals("-v")) {
  // Enable verbose mode
}

Command line arguments in Java can be a powerful tool for customizing the behavior of a program at runtime. Whether we are looking to pass in data, enable certain features, or just give users additional flexibility, they’re worth considering as part of your Java development toolkit.

Conclusion

Command line arguments are a versatile feature in Java that allow you to pass input parameters to your program at runtime. By understanding how to access, validate, and use these arguments, you can create more flexible and user-friendly applications. Whether you’re building a simple utility or a complex application, mastering command line arguments is an essential skill for Java developers.

Frequently Asked Questions