What does “String[] args” contain in java?

Question

When I run the following program:

public class Test
{
    public static void main(String[] args)
    {
        System.out.println(args);
    }
{

Answer 1

Lets make it simple

1: Write a simple class named "test"

public class test {
    public static void main(String[] args) {
        System.out.println("Passed argument is: " + args[0]);
    }
}

2: Now compile it in the following way

javac test.java

3: Now run this by passing an argument

java test Ayoub

** the output will be**

Passed argument is: Ayoub

Answer 2

String[] args in main method is the String array of the command line arguments.

[Ljava.lang.String;@1d1e730 are the class name ([Ljava.lang.String is String[]) and the object's hashcode (@1d1e730);

if you want to print the actual values of the Strings in the array, you can use a simple for-each loop:

for(String arg:args)
    System.out.println(arg);

Answer 3

Update: I just realized I never answered the question "What does “String[] args” contain in java?" :-) It's an array of the command-line arguments provided to the program, each argument being a String in the array.

And we now resume with our regularly-scheduled answer...

args is an array. To see individual command-line arguments, index into the array — args[0], args[1], etc.:

You can loop through the args like this:

public class Test
{
    public static void main(String[] args)
    {
        int index;

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

For java Test one two three, that will output:

args[0]: one
args[1]: two
args[2]: three

Or loop like this if you don't need the index:

public class Test
{
    public static void main(String[] args)
    {
        for (String s : args)
        {
            System.out.println(s);
        }
    }
}

So, what does "[Ljava.lang.String;@153c375" mean?

That's Java's default toString return value for String[] (an array of String). See Object#toString. The [ means "array", the L means "class or interface", and java.lang.String is self-explanatory. That part comes from Class#getName(). The ;@153c375 is ;@ followed by the hashCode of the array as a hex string. (I think the default implementation of hashCode for Object indicates where in memory the array is located, which is why it's different for different invocations of your program, but that's unspecified behavior and wouldn't be any use to you anyway.)

Answer 4

Default implementation of toString method for Object is classname;@identityHashCode. I think, this is what you expect:

System.out.println(java.util.Arrays.toString(args));

Answer 5

It's a form of name mangling used for disambiguating method overloads. The method name is appended by a series of characters describing the parameters and return type: the parameters appear sequentially inside parentheses, and the return type follows the closing parenthesis. The codes are as follows:

• Z: boolean
• B: byte
• C: char
• S: short
• I: int
• J: long
• F: float
• D: double
• L fully-qualified-class-name ; : fully qualified class
• [ type : array of type
• V: void

So according to above codes [Ljava.lang.String;@153c375

Array of string (java.lang.String fully qualified class name) followed by hascode.

Answer 6

String[] args is an Array of Strings and contains the arguments that were given when the application was started. Java does not require you to use the name args, you could just as well specify String[] foo but that will make things unclear if you later read your code again.