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.
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:
public static void main(String[] argument)
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
}
}
Even tho OP is only talking about the String[] args, i want to give a complete example of the public static void main(String[] args).
Public : is an Access Modifier, which defines who can access this Method. Public means that this Method will be accessible by any Class(If other Classes are able to access this Class.).
Static : is a keyword which identifies the class related thing. This means the given Method or variable is not instance related but Class related. It can be accessed without creating the instance of a Class.
Void : is used to define the Return Type of the Method. It defines what the method can return. Void means the Method will not return any value.
main: is the name of the Method. This Method name is searched by JVM as a starting point for an application with a particular signature only.
String[] args : is the parameter to the main Method.
If you look into JDK source code (jdk-src\j2se\src\share\bin\java.c):
/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
"([Ljava/lang/String;)V");
...
{ /* Make sure the main method is public */
...
mods = (*env)->CallIntMethod(env, obj, mid);
if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
message = "Main method not public.";
messageDest = JNI_TRUE;
goto leave;
...
You can see that the starting method in java must be named main and must have the specific signature public static void main(String[] args)
The code also tells us that the public static void main(String[] args) is not fixed, if you change the code in (jdk-src\j2se\src\share\bin\java.c) to another signature, it will work but changing this will give you other possible problems because of the java specs
Offtopic: It's been 7 years since OP asked this question, my guess is that OP can answer his own question by now.
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.
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
}
Explanation in simple layman's language.
The main method expects us to provide some arguments when we direct our JVM to the class name. That means, suppose your file name is Try.java, now to execute this in command prompt you write "javac Try.java" to compile followed by "java Try" to execute. Now suppose instead of writing simply "java Try" you write "java Try 1". Here you have passed an argument "1". This will be taken by your main method even if you don't use it in your code.
If you want to check whether your main method has actually taken the argument "1" or not. Simply, inside your main method type the following:
for(int i = 0; i < args.length; i++) {
System.out.println("Argument is: "+args[i]);
}
When you finish your code, you will turn it into a file with the extension .java, which can be run by double clicking it, but also throughout a console (terminal on a mac, cmd.exe on windows) which lets the user do many things. One thing is they can see console messages (System.out.print or System.out.println) which they can't see if they double click. Another thing they can do is specify parameters, so normally you would use the line
java -jar MyCode.jar
after navigating to the folder of the program with
cd C:My/Code/Location
on windows or
cd My/Code/Location
on Mac (notice that mac is less clunky) to run code, but to specify parameters you would use
java -jar MyCode.jar parameter1 parameter2
These parameters stored in the args array, which you can use in your program is you want to allow the user to control special parameters such as what file to use or how much memory the program can have. If you want to know how to use an array, you could probably find a topic on this site or just google it. Note that any number of parameters can be used.
I think it's pretty well covered by the answers above that String args[] is simply an array of string arguments you can pass to your application when you run it. For completion, I might add that it's also valid to define the method parameter passed to the main method as a variable argument (varargs) of type String:
public static void main (String... args)
In other words, the main method must accept either a String array (String args[]) or varargs (String... args) as a method argument. And there is no magic with the name args either. You might as well write arguments or even freddiefujiwara as shown in below e.gs.:
public static void main (String[] arguments)
public static void main (String[] freddiefujiwara)
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.
in
public static void main(String args[])
args is an array of console line argument whose data type is String.
in this array, you can store various string arguments by invoking them at the command line as shown below:
java myProgram Shaan Royal
then Shaan and Royal will be stored in the array as
arg[0]="Shaan";
arg[1]="Royal";
you can do this manually also inside the program, when you don't call them at the command line.
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"]
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)
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'
The style dataType[] arrayRefVar is preferred. The style dataType arrayRefVar[] comes from the C/C++ language and was adopted in Java to accommodate C/C++ programmers.
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"));
package commandLine;
public class commandLine {
public static void main(String[] args) {
System.out.println("There are " +args.length+ " Command-line Arguments");
System.out.println("They are: ");
for(int i=0;i<args.length;i++){
System.out.println("arg["+i+"]: "+args[i]);
}
}
}
I wanted to check the length of my command-line arguments and loop through them to display the array of command lines. However, it says my command line arguments are 0? How can this be?
Official Java tutorial about command-line arguments.
Command-Line Arguments
A Java application can accept any number of arguments from the command
line. This allows the user to specify configuration information when
the application is launched.
The user enters command-line arguments when invoking the application
and specifies them after the name of the class to be run. For example,
suppose a Java application called Sort sorts lines in a file. To sort
the data in a file named friends.txt, a user would enter:
java Sort friends.txt
When an application is launched, the runtime
system passes the command-line arguments to the application's main
method via an array of Strings. In the previous example, the
command-line arguments passed to the Sort application in an array that
contains a single String: "friends.txt".
Echoing Command-Line Arguments
The Echo example displays each of its command-line arguments on a line
by itself:
public class Echo {
public static void main (String[] args) {
for (String s: args) {
System.out.println(s);
}
}
}
The following example shows how a user might run Echo. User input is
in italics.
java Echo Drink Hot Java
Drink
Hot
Java
Note that the application
displays each word — Drink, Hot, and Java — on a line by itself. This
is because the space character separates command-line arguments. To
have Drink, Hot, and Java interpreted as a single argument, the user
would join them by enclosing them within quotation marks.
java Echo "Drink Hot Java" Drink Hot Java
If you are using IDE (Eclipse or etc.) you have to specify command-line arguments via some kind of run configuration. For example for Eclipse:
In have the command line is essentially of the form
java [vm options] class/jar [arguments]
Only these final arguments are given to you in the array. This is unlike a standard C program where you receive the command name also.
I am learning java using a book. There is this exercise that I can't get to work properly. It adds two doubles using the java class Double. When I try to run this code in Eclipse it gives me the error in the title.
public static void main(String[] args) {
Double d1 = Double.valueOf(args[0]);
Double d2 = Double.valueOf(args[1]);
double result = d1.doubleValue() + d2.doubleValue();
System.out.println(args[0] + "+" + args[1] + "=" + result);
}
Problem
This ArrayIndexOutOfBoundsException: 0 means that the index 0 is not a valid index for your array args[], which in turn means that your array is empty.
In this particular case of a main() method, it means that no argument was passed on to your program on the command line.
Possible solutions
If you're running your program from the command line, don't forget to pass 2 arguments in the command (2, because you're accessing args[0] and args[1])
If you're running your program in Eclipse, you should set the command line arguments in the run configuration. Go to Run > Run configurations... and then choose the Arguments tab for your run configuration and add some arguments in the program arguments area.
Note that you should handle the case where not enough arguments are given, with something like this at the beginning of your main method:
if (args.length < 2) {
System.err.println("Not enough arguments received.");
return;
}
This would fail gracefully instead of making your program crash.
This code expects to get two arguments when it's run (the args array).
The fact that accessing args[0] causes a java.lang.ArrayIndexOutOfBoundsException means you aren't passing any.
The static method main, which receives an array of strings. The array should have two elements: the path where the files are located (at index 0), and the name of the files to process (at index 1). For example, if the name was “Walmart” then the program should use “Walmart.cmd” (from which it will read commands) and “Walmart.pro” (from which it will read/write products).
I don't want anyone to write the code for me because this is something I need to learn. However I've been reading this through and the wording is confusing. If someone could help me understand what it wants from me through pseudo-code or an algorithm it would be greatly appreciated.
Where I'm confused is how to initialize arg[0] and arg[1] and exactly
what they are being initialized to.
The main method's String array input argument consists of whatever String arguments you pass to the program's main method when you run the program. For example, here is a simple program that loops over args and prints a nice message with each argument's index and value on a separate line:
package com.example;
public class MainExample {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.printf("args[%d]=%s\n", i, args[i]);
}
}
}
Once you've compiled the program, you can run it on the command-line and pass it some arguments:
java -cp . com.example.MainExample eh? be sea 1 2 3 "multiple words"
Output:
args[0]=eh?
args[1]=be
args[2]=sea
args[3]=1
args[4]=2
args[5]=3
args[6]=multiple words
So lets explain to you
Create a class Inventory : if you don't know how to create a class google it just as is
The static method main: Every executable class in java (at least from the console) has the main method you should google java main method and propably in the same place you find it you will see the default arguments that it receives
When you learn about the default arguments of method main you will undertand about the 'args' that has to be on it
You will have t study the class String google it "java String class"
You will have to study the class File google it "java File class"
At the end everything else would be just logic and I beleave you have learned some at this point.
public class Inventory { // class inventory
public static void main(String[] args) // main method
{
if(args.length==2){ // check if args contains two elements
String filePath = args[0];
String fileName = args[1];
filePath+= System.getProperty("file.separator")+fileName;
File fileCMD = new File(filePath+".cmd");
//fileCMD.createNewFile();
File filePRO =new File(filePath+".pro");
//filePRO.createNewFile();
}
else {
//write the code to print the message Usage: java Inventory Incorrect number of parameters for a while and exit the program.
}
}
This is what I've understood. Basically you have to write a program to create two files, one called fileName.cmd and the other fileName.pro. You have to construct the path of the files using the arguments (input parameters of the main method) and system's file separator. If the arguments don't have two elements you have to print the 'invalid' message. That's it.
Where I'm confused is how to initialize arg[0] and arg[1] and exactly
what they are being initialized to.
You have to use command line to pass the arguments and launch the program , something like the following code in cmd or terminal:
java inventory thePath theFileName
That's how it get initialized.
When I run the code give below, the following message showed up. What does it mean and how do I overcome it in this instance?
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
at ifDemo.main(ifDemo.java:5)
public class ifDemo {
public static void main (String [] args)
{
int x= Integer.parseInt(args[0]);
double half=0.0;
if (x!=0)
{
half=x/2.0;
System.out.println(x+ "/2 = "+half);
}
if (x==0)
{
System.out.println("The value of x is "+x);
}
int y=x*5;
char grade='F';
if(y>=85)
{
grade='A';
}
if (y>=70 && y<85)
grade='C';
System.out.println("y= "+y+ "and grade equal to "+grade);
}
}
Essentially this means that you are trying to access an index in the args array that doesn't exist.
In your code you have:
int x= Integer.parseInt(args[0]);
And this error is complaining that you actually don't have an index 0 in your args array, i.e the array is empty.
To remedy this, you need to pass your program command line arguments when it is run, in other words, run it as java ifDemo Some Integer Here
For further reading try this, also Google is Your Friend
While running the code you may not be passing any value that x can get a value from arg[0].
Pass value while running the code, this will solve the issue.
Are you using the command-line for executing it?
If you are trying to run the program in Command Prompt then be sure to provide the command line argument. I tried running the program and got no errors.
When you are running the program from the command line you are forgetting to add an argument as so:
java ifDemo.class 1
So essentially the variable args contains absolutely nothing. Therefore, when you try to get the value of args[0] it is throwing the ArrayIndexOutOfBoundsException. You can read more about it here.
What you could add is a form of validation that checks if the user has entered a number and, if they have not, tell them. The code for that would look something like this:
if(args == null || args.length == 0) {
System.out.println("Please enter a number as a command line argument.");
System.exit(0);
}
Or you could look into getting input from the console and using a do while loop for validation of that. If you want a code example just let me know!
int x= Integer.parseInt(args[0]);
In that line above, you are indexing into an array, assuming it has at least 1 element. Are you sure it has one element in it? Are you calling your java program and passing in a number?
int x= Integer.parseInt(args[0]);
This is trying to read the first command line argument.
It will fail with the exception you describe when there are none.
You should update the program with a check for the command line arguments and add an error message if they are amiss.
Run it as java ifDemo xxx where xxx is some integer.
args is an array of String which are called Command line arguments. So, if you run your program from command line as java ifDemo 10 12, then args will contain [10,12] , args[0] will be 10, args[1] will be 12 and args.length will be 2.
This line is throwing an error because you didn't run the program with command line arguments.
int x= Integer.parseInt(args[0]);
args is empty and you are trying to access the 1st element of the array which causes ArrayIndexOutOfBoundsException, thrown to indicate that an array has been accessed with an illegal index. The index is either negative or greater than or equal to the size of the array.
You are not passing an integer as command line argument int x= Integer.parseInt(args[0]);
args[0] is assigned a value by command line arguement.
Compile and run program in following way:
javac ifDemo.java
java ifDemo 23
When you run the program, args[0] is 23.
Earlier as you were not providing any argument by command line, so args[0] was not set and you were getting an array-outofbound-exception.