Using Command-Line Arguments

On many systems it is possible to pass arguments from the command line (these are known as command-line arguments) to an application by including a parameter of type String[] (i.e., an array of Strings) in the parameter list of main, exactly as we have done in every application in the book. By convention, this parameter is named args. When an application is executed using the java command, Java passes the command-line arguments that appear after the class name in the java command to the application's main method as Strings in the array args. The number of arguments passed in from the command line is obtained by accessing the array's length attribute. For example, the command "java MyClass a b" passes two command-line arguments to application MyClass. Note that command-line arguments are separated by white space, not commas. When this command executes, MyClass's main method receives the two-element array args (i.e., args.length is 2) in which args[ 0 ] contains the String "a" and args[ 1 ] contains the String "b". Common uses of command-line arguments include passing options and file names to applications.

Figure 7.21 uses three command-line arguments to initialize an array. When the program executes, if args.length is not 3, the program prints an error message and terminates (lines 912). Otherwise, lines 1432 initialize and display the array based on the values of the command-line arguments.

Figure 7.21. Initializing an array using command-line arguments.

(This item is displayed on pages 324 - 325 in the print version)

 1 // Fig. 7.21: InitArray.java
 2 // Using command-line arguments to initialize an array.
 3
 4 public class InitArray
 5 {
 6 public static void main( String args[] )
 7 {
 8 // check number of command-line arguments
 9 if ( args.length != 3 )
10 System.out.println(
11 "Error: Please re-enter the entire command, including
" +
12 "an array size, initial value and increment." );
13 else
14 {
15 // get array size from first command-line argument
16 int arrayLength = Integer.parseInt( args[ 0 ] );
17 int array[] = new int [ arrayLength ]; // create array
18
19 // get initial value and increment from command-line argument
20 int initialValue = Integer.parseInt( args[ 1 ] );
21 int increment = Integer.parseInt( args[ 2 ] ); 
22
23 // calculate value for each array element 
24 for ( int counter = 0; counter < array.length; counter++ )
25  array[ counter ] = initialValue + increment * counter; 
26
27 System.out.printf( "%s%8s
", "Index", "Value" );
28
29 // display array index and value
30 for ( int counter = 0; counter < array.length; counter++ )
31 System.out.printf( "%5d%8d
", counter, array[ counter ] );
32 } // end else
33 } // end main
34 } // end class InitArray
 
java InitArray
Error: Please re-enter the entire command, including
an array size, initial value and increment.
 
 
java InitArray 5 0 4
Index Value
 0 0
 1 4
 2 8
 3 12
 4 16
 
 
java InitArray 10 1 2
Index Value
 0 1
 1 3
 2 5
 3 7
 4 9
 5 11
 6 13
 7 15
 8 17
 9 19
 

The command-line arguments become available to main as Strings in args. Line 16 gets args[ 0 ]a String that specifies the array sizeand converts it to an int value that the program uses to create the array in line 17. The static method parseInt of class Integer converts its String argument to an int.

Lines 2021 convert the args[ 1 ] and args[ 2 ] command-line arguments to int values and store them in initialValue and increment, respectively. Lines 2425 calculate the value for each array element.

The output of the first sample execution indicates that the application received an insufficient number of command-line arguments. The second sample execution uses command-line arguments 5, 0 and 4 to specify the size of the array (5), the value of the first element (0) and the increment of each value in the array (4), respectively. The corresponding output indicates that these values create an array containing the integers 0, 4, 8, 12 and 16. The output from the third sample execution illustrates that the command-line arguments 10, 1 and 2 produce an array whose 10 elements are the nonnegative odd integers from 1 to 19.

Introduction to Computers, the Internet and the World Wide Web

Introduction to Java Applications

Introduction to Classes and Objects

Control Statements: Part I

Control Statements: Part 2

Methods: A Deeper Look

Arrays

Classes and Objects: A Deeper Look

Object-Oriented Programming: Inheritance

Object-Oriented Programming: Polymorphism

GUI Components: Part 1

Graphics and Java 2D™

Exception Handling

Files and Streams

Recursion

Searching and Sorting

Data Structures

Generics

Collections

Introduction to Java Applets

Multimedia: Applets and Applications

GUI Components: Part 2

Multithreading

Networking

Accessing Databases with JDBC

Servlets

JavaServer Pages (JSP)

Formatted Output

Strings, Characters and Regular Expressions

Appendix A. Operator Precedence Chart

Appendix B. ASCII Character Set

Appendix C. Keywords and Reserved Words

Appendix D. Primitive Types

Appendix E. (On CD) Number Systems

Appendix F. (On CD) Unicode®

Appendix G. Using the Java API Documentation

Appendix H. (On CD) Creating Documentation with javadoc

Appendix I. (On CD) Bit Manipulation

Appendix J. (On CD) ATM Case Study Code

Appendix K. (On CD) Labeled break and continue Statements

Appendix L. (On CD) UML 2: Additional Diagram Types

Appendix M. (On CD) Design Patterns

Appendix N. Using the Debugger

Inside Back Cover



Java(c) How to Program
Java How to Program (6th Edition) (How to Program (Deitel))
ISBN: 0131483986
EAN: 2147483647
Year: 2003
Pages: 615

Similar book on Amazon

Flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net