Class notes(week 5) on command line arguments

of 9
Class Notes on Command line arguments and basics of I/O
operations (Week - 5)
Contents: - What are Command Line Arguments? How to use them? Keyboard input using BufferedReader & Scanner
classes
Command Line Arguments
During program execution, information passed following a programs name in the command line is called
Command Line Arguments. Java application can accept any number of arguments directly from the command
line. The user can enter command-line arguments when invoking the application. When running the java
program from java command, the arguments are provided after the name of the class separated by space.
Example : While running a class Demo, you can specify command line arguments as
java Demo arg1 arg2 arg3 …
class Demo{
public static void main(String b[]){
System.out.println("Argument one = "+b[0]);
System.out.println("Argument two = "+b[1]);
}
}
Run the code as javac Demo apple orange
You must get an output as below.
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:
java Sort friends.txt

of 9
When an application is launched, the runtime system passes the command-line arguments to the application's
main method via an array of Strings. In the previous example, the command-line arguments passed to the Sort
application in an array that contains a single String: "friends.txt".
Command Line Arguments Important Points:
 Command Line Arguments can be used to specify configuration information while launching your
application.
 There is no restriction on the number of command line arguments. You can specify any number of
arguments
 Information is passed as Strings.
 They are captured into the String argument of your main method
How to use command line arguments in java program
Consider the following example. The number of arguments passed during program execution is stored in the
length field of argument name (commonly it is args, note we use String[] args in main method of any
java program)
class CmndLineArguments {
public static void main(String[] args) {
int length = args.length;
if (length <= 0) {
System.out.println("You need to enter some arguments.");
}
System.out.println("Command line arguments were passed:");
for (int i = 0; i < length; i++) {
System.out.println(args[i]);
}
}
}
Output of the program:
Run program with some command line arguments like:
C:>java CmndLineArguments Mahendra zero one two three
OUTPUT
Command line arguments were passed :
Mahendra
zero
one
two
three

of 9
How Java Application Receive Command-line Arguments
In Java, when you invoke an application, the runtime system passes the command-line arguments to the
application‘s main method via an array of Strings.
public static void main( String[] args )
Each String in the array contains one of the command-line arguments.
args[ ] array
Consider a java program sort, which sorts some numbers entered as Command Line Arguments. We run:
java Sort 5 4 3 2 1
the arguments are stored in the args array of the main method declaration as…
Conversion of Command-line Arguments
• If your program needs to support a numeric command-line argument, it must convert a String
argument that represents a number, such as "34", to a number. Here's a code snippet that converts a
command-line argument to an integer,
int firstArg = 0;
if (args.length > 0){
firstArg = Integer.parseInt(args[0]);
}
The parseInt() method is used to get the primitive data type of a certain String. parseInt(String s): This returns
an integer (decimal only). For example consider the following example. The string 9 is converted to int 9.
public class Test{
public static void main(String args[]){
int x =Integer.parseInt("9");
}
}
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.
Command-line Arguments Coding Guidelines:
• Before using command-line arguments, always check the number of arguments before accessing the
array elements so that there will be no exception generated.
• For example, if your program needs the user to input 5 arguments,

of 9
Another example
class StringCLA{
int length=str.length;
if (length<=0){
System.out.println("Enter Some String.");
}
for(int i=0;i<length;i++){
System.out.println(str[i]);
}
}
}
c:> javac StringCLA.java
c:>java StringCLA Its Work !!!
Its
Work
!!!
Note: The application displays each word- Its, Work, and !!!-- on a line by itself. This is because the space
character separates command-line arguments. To have Its, Work, and !!! interpreted as a single argument, the
user would join them by enclosing them within quotation marks.
c:>java StringCLA "Its Work !!!"
Its Work !!!
Reading data from keyboard by InputStreamReader and BufferedReader class:
InputStreamReader class can be used to read data from keyboard. It performs two tasks:
 connects to input stream of keyboard
 converts the byte-oriented stream into character-oriented stream
BufferedReader class:
BufferedReader class can be used to read data line by line by readLine() method.

of 9
Example of reading data from keyboard by InputStreamReader and BufferdReader class:
In this example, we are connecting the BufferedReader stream with the InputStreamReader stream for
reading the line by line data from the keyboard.
//Program of reading data
import java.io.*;
class G5{
public static void main(String args[])throws Exception{
InputStreamReader r=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(r);
System.out.println("Enter ur name");
String name=br.readLine();
System.out.println("Welcome "+name);
}
}
Output:
Enter ur name
Amit
Welcome Amit
Another Example of reading data from keyboard by InputStreamReader and BufferdReader class
until the user writes stop
In this example, we are reading and printing the data until the user prints stop.
import java.io.*;
class G5{
public static void main(String args[])throws Exception{
InputStreamReader r=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(r);
String name="";
while(name.equals("stop")){
System.out.println("Enter data: ");
name=br.readLine();
System.out.println("data is: "+name);
}
br.close(); // BufferedReader Stream is Closed
r.close(); // InputStreamReader Stream is Closed
}
}
Output:
Enter data: Amit
data is: Amit
Enter data: 10

of 9
data is: 10
Enter data: stop
data is: stop
The following figure shows how the stream flows from device buffer to System.in, InputStreamReader object r
and then to BufferedReader object r, and at last to the java program.
Class InputStreamReader
public class InputStreamReader
extends Reader
An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them
into characters using a specified charset. The charset that it uses may be specified by name or may be given
explicitly, or the platform's default charset may be accepted.
Each invocation of one of an InputStreamReader's read() methods may cause one or more bytes to be read
from the underlying byte-input stream. To enable the efficient conversion of bytes to characters, more bytes
may be read ahead from the underlying stream than are necessary to satisfy the current read operation.
For top efficiency, consider wrapping an InputStreamReader within a BufferedReader. For example:
BufferedReader in
= new BufferedReader(new InputStreamReader(System.in));
Class BufferedReader
public class BufferedReader
extends Reader
Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of
characters, arrays, and lines.
The buffer size may be specified, or the default size may be used. The default is large enough for most
purposes.

of 9
In general, each read request made of a Reader causes a corresponding read request to be made of the
underlying character or byte stream. It is therefore advisable to wrap a BufferedReader around any Reader
whose read() operations may be costly, such as FileReaders and InputStreamReaders. For example,
BufferedReader in
= new BufferedReader(new FileReader("foo.in"));
will buffer the input from the specified file. Without buffering, each invocation of read() or readLine() could
cause bytes to be read from the file, converted into characters, and then returned, which can be very
inefficient.
Programs that use DataInputStreams for textual input can be localized by replacing each DataInputStream
with an appropriate BufferedReader.
Input from the keyboard by java.util.Scanner class:
There are various ways to read input from the keyboad, the java.util.Scanner class is one of them. The Scanner class
breaks the input into tokens using a delimiter which is whitespace bydefault. It provides many methods to read and
parse various primitive values.
Commonly used methods of Scanner class:
There is a list of commonly used Scanner class methods:
 public String next(): it returns the next token from the scanner.
 public String nextLine(): it moves the scanner position to the next line and returns the value as a string.
 public byte nextByte(): it scans the next token as a byte.
 public short nextShort(): it scans the next token as a short value.
 public int nextInt(): it scans the next token as an int value.
 public long nextLong(): it scans the next token as a long value.
 public float nextFloat(): it scans the next token as a float value.
 public double nextDouble(): it scans the next token as a double value.
Example of java.util.Scanner class:
import java.util.Scanner;
class ScannerTest{
Scanner sc=new Scanner(System.in);
System.out.println("Enter your rollno");
int rollno=sc.nextInt();
System.out.println("Enter your name");
String name=sc.next();
System.out.println("Enter your fee");
double fee=sc.nextDouble();
System.out.println("Rollno:"+rollno+" name:"+name+" fee:"+fee);
}
}

of 9
Output:
Enter your rollno
111
Enter your name
Ratan
Enter
450000
Rollno:111 name:Ratan fee:450000
Class Scanner
public final class Scanner
extends Object
A simple text scanner which can parse primitive types and strings using regular expressions.
A Scanner breaks its input into tokens using a delimiter pattern, which by default matches whitespace. The
resulting tokens may then be converted into values of different types using the various next methods.
For example, this code allows a user to read a number from System.in:
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
As another example, this code allows long types to be assigned from entries in a file myNumbers:
Scanner sc = new Scanner(new File("myNumbers"));
while (sc.hasNextLong()) {
long aLong = sc.nextLong();
}
The scanner can also use delimiters other than whitespace. This example reads several items in from a string:
String input = "1 fish 2 fish red fish blue fish";
Scanner s = new Scanner(input).useDelimiter("s*fishs*");
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();
prints the following output:
1
2
red
blue
The default whitespace delimiter used by a scanner is as recognized by Character.isWhitespace.
A scanning operation may block waiting for input.

of 9
The next() and hasNext() methods and their primitive-type companion methods (such as nextInt() and hasNextInt())
first skip any input that matches the delimiter pattern, and then attempt to return the next token. Both hasNext
and next methods may block waiting for further input. Whether a hasNext method blocks has no connection to
whether or not its associated next method will block.
Another example showing the use of hasNext(), next() and nextLine():
Source Code Output of the Program
class hasNextExample
{
public static void main(String agrs[]) {
String stest=new String("This is an example!!!");
Scanner sc=new Scanner(stest);
while(sc.hasNext()) {
System.out.println(sc.next());
}
}
}
D:java1>javac hasNextExample.java
D:java1>java hasNextExample
This
is
an
example!!!
D:java1>
class hasNextExample
{
public static void main(String agrs[]) {
String stest=new String("This is an example!!!");
Scanner sc=new Scanner(stest);
while(sc.hasNext()) {
System.out.println(sc.nextLine());
}
}
}
D:java1>javac hasNextExample.java
D:java1>java hasNextExample
This is an example!!!
D:java1>

Class notes(week 5) on command line arguments

Recommended

More Related Content

What's hot (20)

Similar to Class notes(week 5) on command line arguments (20)

More from Kuntal Bhowmick (20)

Recently uploaded (20)

Class notes(week 5) on command line arguments