What is "String args[]"? parameter in main method Java

In Java args contains the supplied command-line arguments as an array of String objects.

In other words, if you run your program in your terminal as :

C:/ java MyProgram one two

then args will contain ["one", "two"].

If you wanted to output the contents of args, you can just loop through them like this...

public class ArgumentExample {
    public static void main(String[] args) {
        for(int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

The program will print in the terminal:

C:/ java MyProgram one two
one
two
    
C:/

Those are for command-line arguments in Java.

In other words, if you run

java MyProgram one two

Then args contains:

[ "one", "two" ]

public static void main(String [] args) {
    String one = args[0]; //=="one"
    String two = args[1]; //=="two"
}

The reason for this is to configure your application to run a particular way or provide it with some piece of information it needs.

If you are new to Java, I highly recommend reading through the official Oracle's Java™ Tutorials.

args contains the command-line arguments passed to the Java program upon invocation. For example, if I invoke the program like so:

$ java MyProg -f file.txt

Then args will be an array containing the strings "-f" and "file.txt".

The following answer is based my understanding & some test.

What is String[] args ?

Ans:

String[] -> As we know this is a simple String array.

args -> is the name of an array it can be anything (e.g. a, ar, argument, param, parameter) no issues with compiler & executed & I tested as well.

E.g:

1. public static void main(String[] argument)

2. public static void main(String[] parameter)

When would you use these args?

Ans->

The main function is designed very intelligently by developers. Actual thinking is very deep. Which is basically developed under consideration of C & C++ based on Command line argument but nowadays nobody uses it more.

1- User can enter any type of data from the command line can be Number or String & necessary to accept it by the compiler which datatype we should have to use? see the thing 2

2- String is the datatype which supports all of the primitive datatypes like int, long, float, double, byte, shot, char in Java. You can easily parse it in any primitive datatype.

E.g: The following program is compiled & executed & I tested as well.

If input is -> 1 1

// one class needs to have a main() method
public class HelloWorld
{
  // arguments are passed using the text field below this editor
  public static void main(String[] parameter)
  {    
System.out.println(parameter[0] + parameter[1]); // Output is 11

//Comment out below code in case of String
    System.out.println(Integer.parseInt(parameter[0]) + Integer.parseInt(parameter[1])); //Output is 2
    System.out.println(Float.parseFloat(parameter[0]) + Float.parseFloat(parameter[1])); //Output is 2.0    
    System.out.println(Long.parseLong(parameter[0]) + Long.parseLong(parameter[1])); //Output is 2    
    System.out.println(Double.parseDouble(parameter[0]) + Double.parseDouble(parameter[1])); //Output is 2.0    

  }
}

String [] args is also how you declare an array of Strings in Java.

In this method signature, the array args will be filled with values when the method is called (as the other examples here show). Since you're learning though, it's worth understanding that this args array is just like if you created one yourself in a method, as in this:

public void foo() {
    String [] args = new String[2];
    args[0] = "hello";
    args[1] = "every";

    System.out.println("Output: " + args[0] + args[1]);

    // etc... the usage of 'args' here and in the main method is identical
}

When a java class is executed from the console, the main method is what is called. In order for this to happen, the definition of this main method must be

public static void main(String [])

The fact that this string array is called args is a standard convention, but not strictly required. You would populate this array at the command line when you invoke your program

java MyClass a b c

These are commonly used to define options of your program, for example files to write to or read from.

String[] args means an array of sequence of characters (Strings) that are passed to the "main" function. This happens when a program is executed.

Example when you execute a Java program via the command line:

java MyProgram This is just a test

Therefore, the array will store: ["This", "is", "just", "a", "test"]

The String[] args parameter is an array of Strings passed as parameters when you are running your application through command line in the OS.

So, imagine you have compiled and packaged a myApp.jar Java application. You can run your app by double clicking it in the OS, of course, but you could also run it using command line way, like (in Linux, for example):

user@computer:~$ java -jar myApp.jar

When you call your application passing some parameters, like:

user@computer:~$ java -jar myApp.jar update notify

The java -jar command will pass your Strings update and notify to your public static void main() method.

You can then do something like:

System.out.println(args[0]); //Which will print 'update'
System.out.println(args[1]); //Which will print 'notify'

In addition to all the previous comments.

public static void main(String[] args) 

can be written as

 public static void main(String...arg)

or

 public static void main(String...strings)

You can also have the syntax below as well.

public static void main(String... args)

here ellipsis i.e. three dots after the data type String specifies zero or multiple arguments (variable number of arguments).

try this:

System.getProperties().getProperty("sun.java.command", 
    System.getProperties().getProperty("sun.rt.javaCommand"));