Accessing arguments in Java - Step-by-Step Execution

Concept Flow - Accessing arguments

Program starts

↓

Main method called with args array

↓

Access args[0

↓

Use arguments in code

↓

Program ends

The program starts and the main method receives an array of arguments. Each argument can be accessed by its index in the array and used in the program.

Execution Sample

Java

public class Main {
  public static void main(String[] args) {
    System.out.println("First arg: " + args[0]);
    System.out.println("Second arg: " + args[1]);
  }
}

This program prints the first two command-line arguments passed to it.

Execution Table

Step	Action	args array content	Accessed argument	Output
1	Program starts, main called	["hello", "world"]	N/A	N/A
2	Access args[0]	["hello", "world"]	"hello"	Prints: First arg: hello
3	Access args[1]	["hello", "world"]	"world"	Prints: Second arg: world
4	Program ends	["hello", "world"]	N/A	N/A

💡 All arguments accessed and printed, program ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
args	["hello", "world"]	["hello", "world"]	["hello", "world"]	["hello", "world"]
args[0]	"hello"	"hello"	"hello"	"hello"
args[1]	"world"	"world"	"world"	"world"

Key Moments - 2 Insights

Why do we use args[0] and args[1] to get the first and second arguments?

Because args is an array where the first element is at index 0, the second at index 1, as shown in execution_table rows 2 and 3.

What happens if we try to access args[2] when only two arguments are passed?

It causes an error because args[2] does not exist. The execution_table shows only args[0] and args[1] accessed safely.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output at Step 2?

A No output

B Prints: Second arg: world

C Prints: First arg: hello

D Error

💡 Hint

Check the Output column at Step 2 in the execution_table.

At which step does the program access the second argument?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the Accessed argument column in the execution_table.

If no arguments are passed, what will happen when accessing args[0]?

A Throws an error

B Prints empty string

C Prints null

D Prints args[0]

💡 Hint

Refer to key_moments about accessing non-existing args index.

Concept Snapshot

Access command-line arguments via the String[] args array in main.
Use args[0], args[1], etc. to get each argument.
Arguments are strings passed when running the program.
Accessing an index out of bounds causes an error.
Always check args length before accessing.

Full Transcript

This visual execution shows how Java programs access command-line arguments through the main method's String array named args. The program starts and receives arguments as an array. Each argument is accessed by its index, starting at zero. The example prints the first two arguments. The execution table traces each step: program start, accessing args[0], accessing args[1], and program end. The variable tracker shows how args and its elements change or are accessed. Key moments clarify why indexing starts at zero and what happens if you access an argument that does not exist. The quiz tests understanding of output at each step and error cases. The snapshot summarizes the key points for quick reference.

Practice

1. What is the correct way to access the first command-line argument in a Java program inside the main method?

easy

A. args.first()

B. args[0]

C. args(0)

D. args.get(0)

Solution

1. Step 1: Understand the type of args

   The args parameter in main is an array of strings.

2. Step 2: Access array elements in Java

   Array elements are accessed using square brackets with the index inside, starting at 0.

3. Final Answer:

   args[0] -> Option B

4. Quick Check:

   Array access uses square brackets [OK]

Hint: Use square brackets to access array elements in Java [OK]

Common Mistakes:

• Using parentheses instead of square brackets
• Trying to call methods like first() on array
• Using get() which is for lists, not arrays

2. Which of the following is the correct signature of the main method to access command-line arguments in Java?

easy

A. public void main(String[] args)

B. public static int main(String[] args)

C. static public void main(String args)

D. public static void main(String args[])

Solution

1. Step 1: Recall the standard main method signature

   The main method must be public, static, return void, and accept a String array parameter.

2. Step 2: Check each option

   public static void main(String args[]) matches the correct signature. public void main(String[] args) is missing static. static public void main(String args) has wrong parameter type. public static int main(String[] args) returns int which is invalid.

3. Final Answer:

   public static void main(String args[]) -> Option D

4. Quick Check:

   Main method must be public static void with String array [OK]

Hint: Main method must be public static void with String array [OK]

Common Mistakes:

• Omitting static keyword
• Wrong return type
• Using single String instead of String array

3. What will be the output of the following Java program if run with arguments java Program Hello World?

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

medium

A. 3
World

B. 2
Hello

C. 2
World

D. 3
Hello

Solution

1. Step 1: Count the command-line arguments

   The program is run with two arguments: "Hello" and "World", so args.length is 2.

2. Step 2: Access the second argument

   args[1] is the second argument, which is "World".

3. Final Answer:

   2 World -> Option C

4. Quick Check:

   args.length=2, args[1]=World [OK]

Hint: args.length counts arguments; args[1] is second argument [OK]

Common Mistakes:

• Counting program name as argument
• Using args[0] as second argument
• Confusing args.length with number of arguments plus one

4. Identify the error in the following Java program that tries to print the first command-line argument:

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

medium

A. Using parentheses instead of square brackets to access array element

B. Missing static keyword in main method

C. Incorrect class name

D. Missing return statement in main

Solution

1. Step 1: Check how array elements are accessed

   In Java, array elements are accessed using square brackets, not parentheses.

2. Step 2: Identify the error in the code

   The code uses args(0) which is invalid syntax and causes a compile error.

3. Final Answer:

   Using parentheses instead of square brackets to access array element -> Option A

4. Quick Check:

   Array access uses square brackets [OK]

Hint: Use square brackets [] for arrays, not parentheses () [OK]

Common Mistakes:

• Using parentheses for array access
• Confusing method call syntax with array access
• Ignoring compile errors due to wrong syntax

5. You want to write a Java program that prints all command-line arguments separated by commas. Which code snippet correctly does this inside main?

hard

A. for(int i=0; i

B. for(String arg : args) {
System.out.print(arg + ", ");
}

C. int i = 0;
while(i <= args.length) {
System.out.print(args[i] + ", ");
i++;
}

D. for(int i=1; i<=args.length; i++) {
System.out.print(args[i] + ", ");
}

Solution

1. Step 1: Understand the goal

   We want to print all arguments separated by commas without trailing comma.

2. Step 2: Analyze each option

   for(int i=0; i

3. Final Answer:

   for(int i=0; i<args.length; i++) { System.out.print(args[i] + (i < args.length - 1 ? ", " : "")); } -> Option A

4. Quick Check:

   Loop with index and conditional comma [OK]

Hint: Use index loop and add comma only if not last element [OK]

Common Mistakes:

• Adding comma after last argument
• Off-by-one errors in loops
• Accessing array out of bounds