What is "String args[]"? parameter in main method Java
What is "String args[]"? parameter in main method Java
Question
I'm just beginning to write programs in Java. What does the following Java code mean?
public static void main(String[] args)
What is
String[] args
?When would you use these
args
?
Source code and/or examples are preferred over abstract explanations
Popular Answer
In Java args
contains the supplied command-line arguments as an array of String
objects.
In other words, if you run your program as 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]);
}
}
}
Read more… Read less…
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 JavaTM 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.
Thing 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
Thing 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
}
I would break up
public static void main(String args[])
in parts.
"public" means that main() can be called from anywhere.
"static" means that main() doesn't belong to a specific object
"void" means that main() returns no value
"main" is the name of a function. main() is special because it is the start of the program.
"String[]" means an array of String.
"args" is the name of the String[] (within the body of main()). "args" is not special; you could name it anything else and the program would work the same.
String[] args
is a collection of Strings, separated by a space, which can be typed into the program on the terminal. More times than not, the beginner isn't going to use this variable, but it's always there just in case.