Using Command-Line Arguments in a Java Application

Java Application ,Command-line arguments can be a manner of specifying configuration houses for an software, and Java is no unique. Instead of clicking on an utility icon from the running device, you may run the Java application from a terminal window. Along with the application call, some of arguments can observe which can be then handed to the application’s start line (i.E., the primary method, in the case of Java).

For instance, NetBeans has a number of startup parameters that can be handed to the software while it is run from a terminal window (e.G.,

specifies a model of the JDK for use rather than the default JDK related to the NetBeans application).

Java Application The Main Method

Let’s study the primary technique to see where the arguments handed to an software seem:

The command-line arguments may be discovered within the

called

For example, allow’s don’t forget an software referred to as

whose simplest action is to print out the command-line arguments passed to it:

public class CommandLineArgs { 
   public static void main(String[] args) {
//check to see if the String array is empty
if (args.length == 0)
{
System.out.println("There were no commandline arguments passed!");
}
       //For each String in the String array
//print out the String.
for(String argument: args)
{
System.out.println(argument);
}
}
}

Java Application Syntax of Command Line Arguments

The Java Runtime Engine (JRE) expects arguments to be passed following a particular syntax, like so:

java ProgramName value1 value2

Above, “java” invokes the JRE, which is followed by means of the call of this system you’re calling. These are accompanied via any arguments to this system. There is not any restrict to the number of arguments a software can take, but the order is essential. The JRE passes the arguments inside the order in which they seem on the command line. For example, keep in mind this code snippet from above:

public class CommandLineArgs2 {​
   public static void main(String[] args) {
if (args.length == 0)
{
System.out.println("There were no commandline arguments passed!");
}

When arguments are passed to a Java application, args[0] is the primary detail of the array (value1 above), args[1] is the second element (value2), and so on. The code args.Period() defines the period of the array.

Java Application Passing Command-Line Arguments

In NetBeans, we are able to pass command-line arguments without having to build the application and run it from a terminal window. To specify the command-line arguments:

  1. Right-click on the project folder in theProjectswindow.
  2. Choose thePropertiesoption to open Project Propertieswindow.
  3. In theCategorieslist on the right-hand side, chooseRun
  4. In theArgumentstextbox that appears, specify the command-line arguments you want to pass to the application. For example, if we enterApple Banana Carrotin theArgumentstextbox and run theCommandLineArgsprogram listed above, we will get the output:

Parsing the Command-Line Arguments

Typically, a command line argument is passed with some information about what to do with the value being passed. The argument informing the application what the argument is for typically has a hyphen or two before its name. For example, the NetBeans example for the startup parameter specifying the JDK path is

This means you’ll need to parse the command-line arguments to figure out what to do with the values. There are several Java command-line frameworks for parsing command-line arguments. Or you could write a simple command-line parser if the arguments you need to pass are not that many:

The code above either prints the arguments or add them together if they are integers. For example, this command line argument would add the numbers:

java CommandLineArgs -addnumbers 11 22 33 44