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
|
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