Java command line arguments list

Saved searches

Use saved searches to filter your results more quickly

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session.

License

learn-co-curriculum/java-command-line-args

This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Sign In Required

Please sign in to use Codespaces.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

Let’s step away from File IO for a minute to talk about a feature of Java we have been ignoring, but might find helpful for working with files: command-line arguments.

Consider the main() method we have been using to execute our Java programs:

class Example < public static void main(String[] args) < // Write some code here > >

Remember a couple modules back when we were learning about methods and discussed the parameter list of the main() method. The main() method takes in a String array or arguments. Currently, we haven’t been making use of this array at all. until now that is!

How to Pass Command-Line Arguments into Java

Command-line arguments are just what they sound like — arguments that are passed into a program through the command line! In Java, we list out the arguments after we run the java command. Let’s look at an example:

public class Example < public static void main(String[] args) < for (String arg : args) < System.out.println(arg); > > >

Now let’s compile the program and run it via the command-line:

javac Example.java java Example one two three 

The output of the code above would be:

We just successfully passed in 3 arguments to our program via the command-line! Notice that each of the arguments, «one», «two», and «three», are separated by a space when entered on the command line and then processed into Java as array elements.

Now that we know how to pass in command-line arguments, let’s show a more useful example where we actually use the command-line arguments. Perhaps we want our program to take in some integer values so we can multiply them:

public class Example < public static void main(String[] args) < int[] numbers = new int[args.length]; for (int index = 0; index < args.length; index++) < numbers[index] = Integer.parseInt(args[index]); > int product = 1; for (int number: numbers) < product = product * number; > System.out.println("The product is: " + product); > >

If we run the program above like this:

The output of the program will be:

As we can see in the program above, we take the arguments and parse them into int values that we can multiply. We then iterate through those integers to come up with a product.

Now let’s modify this program a little to add some exception handling. For example, the program would throw a NumberFormatException if we were to pass in arguments like «one», «two», and «three». We also need to handle the case when the user does not enter in any command-line arguments:

public class Example < public static void main(String[] args) < if (args.length == 0) < System.out.println("No command-line arguments were entered."); > else < int[] numbers = new int[args.length]; try < for (int index = 0; index < args.length; index++) < numbers[index] = Integer.parseInt(args[index]); > int product = 1; for (int number: numbers) < product = product * number; > System.out.println("The product is: " + product); > catch(NumberFormatException exception) < System.err.println("Did not enter in an integer argument."); System.err.println(exception.getMessage()); > > > >

Now if we neglect to provide command-line arguments for our example code:

We would get this as our output:

No command-line arguments were entered. 

If we fail to enter an integer in for the command-line arguments:

java Example one two three 

The program will now handle this error gracefully:

Did not enter in an integer argument. For input string: "one" 

Command-Line Arguments in IntelliJ

This is all great! But what if we are running our program using the IDE IntelliJ instead of the command-line?

Next to the green play button is an «Edit Run/Debug configurations» dropdown. Go ahead and click on it and then click «Edit Configurations. «:

This will bring up the «Edit Run/Debug configurations» dialog box.

On the left-hand side, select the correct application to edit. Then enter in the command-line arguments in the «Program arguments» box:

At the bottom of the dialog box, click the «Apply» button and then the «OK» button. This will save the run configuration. Now go ahead and run the program! This should now run the program with the arguments entered.

Passing Files as Command-Line Arguments

Let’s circle back around to File IO now and show how we can even pass in a file as a command-line argument! Consider the FileIOMain class from the previous lesson:

import java.io.File; import java.io.IOException; import java.util.Scanner; public class FileIOMain < public static void main(String[] args) < String content = ""; File file = new File("simple.txt"); try (Scanner reader = new Scanner(file)) < while (reader.hasNextLine()) < content = content.concat(reader.nextLine()); content = content.concat("\n"); > System.out.println(content); > catch (IOException ioException) < ioException.printStackTrace(); > > >

Let’s modify this to take in a command-line argument where we specify the file! We’ll re-use the simple.txt file too for our program to read in.

import java.io.File; import java.io.IOException; import java.util.Scanner; public class FileIOMain < public static void main(String[] args) < // Ensure that an argument was passed in if (args.length != 1) < System.out.println("Please specify one file path as a command-line argument."); > else < String content = ""; // We only care about the first argument, so we can use the syntax `args[0]` File file = new File(args[0]); try (Scanner reader = new Scanner(file)) < while (reader.hasNextLine()) < content = content.concat(reader.nextLine()); content = content.concat("\n"); > System.out.println(content); > catch (IOException ioException) < ioException.printStackTrace(); > > > >

Now that we have modified the program above to take in a command-line argument, let’s see if it can still read the file we pass in! If running in IntelliJ, edit the «Run/Debug configurations» and type in the file path under the «Program Arguments» box.

In this example, we’ll go ahead and pass in another relative path of the file. We could enter an absolute path here as well though! When entering a relative path, make sure that the path is relative to where the program is being run!

Now we’ll go ahead and run it:

Источник

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:

When an application is launched, the runtime system passes the command-line arguments to the application’s main method via an array of String s. 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:

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

Parsing Numeric Command-Line Arguments

If an application needs to support a numeric command-line argument, it must convert a String argument that represents a number, such as «34», to a numeric value. Here is a code snippet that converts a command-line argument to an int :

int firstArg; if (args.length > 0) < try < firstArg = Integer.parseInt(args[0]); >catch (NumberFormatException e) < System.err.println("Argument" + args[0] + " must be an integer."); System.exit(1); >>

parseInt throws a NumberFormatException if the format of args[0] isn’t valid. All of the Number classes — Integer , Float , Double , and so on — have parseXXX methods that convert a String representing a number to an object of their type.

Источник