U-III Prt-2.pptx0 for Java and hardware coding...

U-III
Other Utility classes: String Tokenizer, Date,
Calendar, Gregorian Calendar, Scanner
Java Input/Output: Exploring java.io, Java I/O
classes and interfaces, File, Stream classes,
byte stream, character stream, serialization

java.util.Scanner
• Scanner class in Java is found in the java.util package.
• public final class Scanner extends Object implements Iterator<String>, Closeable
• Java provides various ways to read input from the keyboard, the java.util.Scanner
class is one of them.
• The Java Scanner class breaks the input into tokens using a delimiter which is
whitespace by default. It provides many methods to read and parse various
primitive values.
• By the help of Scanner in Java, we can get input from the user in primitive types
such as int, long, double, byte, float, short, etc.
• To get the instance of Java Scanner which reads input from the user, we need to
pass the input stream (System.in) in the constructor of Scanner class. For
Example:
Scanner in = new Scanner(System.in);
•To get the instance of Java Scanner which parses the strings, we need to pass the
strings in the constructor of Scanner class. For Example:
Scanner in = new Scanner("Hello Javatpoint");

Using Scanner class methods
import java.util.*;
public class ScannerClassExample
{
public static void main(String args[])
{
String s = "Hello, This is Java class.";
//Create scanner Object and pass string in it
Scanner scan = new Scanner(s);
//Check if the scanner has a token
System.out.println("Boolean Result: " +
scan.hasNext());
//Print the string
System.out.println("String:”+scan.nextLine());
//Using scanner class methods to read string,int,float
System.out.println("--------Enter Your Details--");
Scanner in = new Scanner(System.in);
System.out.print("Enter your name: ");
String name = in.nextLine();
System.out.println(" Name: “ +name);
System.out.print("Enter your age: ");
int i = in.nextInt();
System.out.println("Age: " + i);
System.out.print("Enter your salary: ");
double d = in.nextDouble();
System.out.println("Salary: " + d);
} }
Output:
Boolean Result: true
String: Hello, This is Java class.
-------Enter Your Details---------
Enter your name: Abhishek
Name: Abhishek
Enter your age: 23
Age: 23
Enter your salary: 25000
Salary: 25000.0

StringTokenizer
• The processing of text often consists of parsing a formatted input string. Parsing is
the division of text into a set of discrete parts, or tokens.
• StringTokenizer implements the Enumeration interface.
• To use StringTokenizer, you specify an input string and a string that contains
delimiters.
• Delimiters are characters that separate tokensfor example, “,;:” sets the delimiters
to a comma, semicolon,and colon.
• The default set of delimiters consists of the whitespace characters: space,
tab,newline, and carriage return.
• The StringTokenizer constructors are shown here:
• StringTokenizer(String str)
• StringTokenizer(String str, String delimiters)
• StringTokenizer(String str, String delimiters, boolean delimAsToken)
• In all versions, str is the string that will be tokenized.
• In the first version, the default delimiters are used.
• In the second and third versions, delimiters is a string that specifies the delimiters.
• In the third version, if delimAsToken is true, then the delimiters are also returned
as tokens when the string is parsed.

StringTokenizer to parse “key=value” pairs
// Demonstrate StringTokenizer.
import java.util.StringTokenizer;
class STDemo {
String in = "title=Java: The Complete Reference;" +
"author=Schildt;" +
"publisher=Osborne/McGraw-Hill;" +
"copyright=2007";
public static void main(String args[]) {
StringTokenizer st = new StringTokenizer(in, "=;");
while(st.hasMoreTokens()) {
String key = st.nextToken();
String val = st.nextToken();
System.out.println(key + "t" + val);
} } }
The output from this program is shown here:
title Java: The Complete Reference
author Schildt
publisher Osborne/McGraw-Hill
copyright 2007

Java program that reads a line of integers, and displays each integer, and the sum
of all the integers
import java.util.*;
class StringTokenizerDemo {
int n;
int sum = 0;
Scanner sc = new Scanner(System.in);
System.out.println("Enter integers
with one space gap:");
String s = sc.nextLine();
StringTokenizer st = new
StringTokenizer(s, " ");
while (st.hasMoreTokens()) {
String temp = st.nextToken();
n = Integer.parseInt(temp);
System.out.println(n);
sum = sum + n;
}
System.out.println("sum of the
integers is: " + sum);
}
}
OUTPUT:
Enter integers with one space gap:
10 20 30 40 50
10 20 30 40 50
sum of the integers is: 150

java.util.Date class
• The java.util.Date class represents date and time in
java. It provides constructors and methods to deal
with date and time in java.
• java.util.Date Constructors
• Date() : Creates date object representing current
date and time.
• Date(int year, int month, int date)
• Deprecated. As of JDK version 1.1, replaced
by Calendar.set(year + 1900, month,
date) or GregorianCalendar(year + 1900, month,
date).

java.util.Date class
// Program to demonstrate methods of
Date class
import java.util.*;
public class DateDemo {
public static void main(String[] args) {
// Creating date
Date d1 = new Date(2000, 11, 21);
Date d2 = new Date(); // Current date
Date d3 = new Date(2010, 1, 3);
boolean a = d3.after(d1);
System.out.println("Date d1 " + d1);
System.out.println("Date d3 comes after
" + "date d1: " + a);
boolean b = d3.before(d2);
System.out.println("Date d3 comes
before "+ "date d2: " + b);
int c = d1.compareTo(d2);
System.out.println(c);
} }
Output:
Date d1 Fri Dec 21 00:00:00 IST 3900
Date d2 Mon Nov 28 13:09:03 IST 2022
Date d3 Thu Feb 03 00:00:00 IST 3910
Date d3 comes after date d1: true
Date d3 comes before date d2: false
1
int compareTo(Date date)
Compares the value of the invoking
object with that of date. Returns 0 if
the values are equal. Returns a
negative value if the invoking object is
earlier than date. Returns a positive
value if the invoking object is later
than date.

Java Calendar Class
• Java Calendar class is an abstract class
that provides methods for converting
date between a specific instant in
time and a set of calendar fields such
as MONTH, YEAR, HOUR, etc.
• It inherits Object class and
implements the Comparable
interface.
Output:
Sun Jul 29 07:42:05 PDT 2018
Thu Jul 29 07:42:05 PDT 2027
Current Calendar's Year: 2018
Current Calendar's Day: 28
Current MINUTE: 10
Current SECOND: 45
import java.util.Calendar;
public class CalendaraddExample {
// create a new calendar
Calendar cal = Calendar.getInstance();
// print the current date and time
System.out.println("" + cal.getTime());
// add 9 years
cal.add((Calendar.YEAR), 9);
// print the modified date and time
System.out.println("" + cal.getTime());
System.out.println("Current Calendar's Year: " +
calendar.get(Cal.YEAR));
System.out.println("Current Calendar's Day: " +
calendar.get(Cal.DATE));
System.out.println("Current MINUTE: " +
calendar.get(Cal.MINUTE));
System.out.println("Current SECOND: " +
calendar.get(Cal.SECOND));
}
}

Types of Streams
• In Java, a stream is a path along which the data flows. Every stream has
a source and a destination.
• A stream is a sequence of data. In Java, a stream is composed of bytes. It's
called a stream because it is like a stream of water that continues to flow.
OutputStream
• Java application uses an output stream to write data to a destination; it
may be a file, an array, peripheral device or socket.
• InputStream
• Java application uses an input stream to read data from a source; it may be
a file, an array, peripheral device or socket.
• While an Writing streams writes data into a source(file) , an Reading
streams is used to read data from a source(file).
• The java.io package contains a large number of stream classes that provide
capabilities for processing all types of data.
• These classes may be categorized into two groups based on the data type
on which they operate.
• Byte stream classes
• Character stream classes

U-III Prt-2.pptx0 for Java and hardware coding...

Byte Stream Classes
• Byte stream classes have been designed to provide functional
features for creating and manipulating streams and files for
reading and writing bytes.
• Java provides two kinds of byte stream classes: input stream
classes and output stream classes.
• The super class InputStream is an abstract class, and, therefore,
we cannot create instances of this class. Rather, we must use the
subclasses that inherit from this class.
• The super class OutputStream is an abstract class and therefore
we cannot instantiate it. The several subclasses of the
OutputStream can be used for performing the output operations.

Character Stream Classes
• Character streams can be used to read and write 16-bit Unicode
characters. Like byte streams, there are two kinds of character stream
classes, namely, reader stream classes and writer stream classes.
• The Reader class is the superclass for all character-oriented input stream
classes. Being an abstract class, the Reader class cannot be instantiated
hence its subclasses are used.
• Reader stream classes are functionally very similar to the input stream
classes, except input streams use bytes as their fundamental unit of
information, while reader streams use characters.
• The Writer class is an abstract class which acts as a base class for all the
other writer stream classes.

Standard Streams
• All Java programs automatically import the java.lang package. This package
defines a class called System.
• System also contains three predefined stream variables: in, out, and err.
• These fields are declared as public, static, and final within System. This
means that they can be used by any other part of your program and
without reference to a specific System object.
• Java provides the following three standard streams −
• Standard Input − This is used to feed the data to user's program and usually
a keyboard is used as standard input stream and represented as System.in.
• Standard Output − This is used to output the data produced by the user's
program and usually a computer screen is used for standard output stream
and represented as System.out.
• Standard Error − This is used to output the error data produced by the
user's program and usually a computer screen is used for standard error
stream and represented as System.err.
• System.in is an object of type InputStream.
• System.out and System.err are objects of type PrintStream.

Reading Console Input
• The preferred method of reading console input is to use a character-oriented stream,
which makes your program easier to internationalize and maintain.
• In Java, console input is accomplished by reading from System.in. To obtain a
character based stream that is attached to the console, wrap System.in in a
BufferedReader object.
• BufferedReader supports a buffered input stream. Its most commonly used
constructor is shown here:
BufferedReader(Reader inputReader)
• Here, inputReader is the stream that is linked to the instance of BufferedReader that
is being created.
• Reader is an abstract class. One of its concrete subclasses is InputStreamReader.
• To obtain an InputStreamReader object that is linked to System.in, use the following
constructor:
InputStreamReader(InputStream inputStream)
• Because System.in refers to an object of type InputStream, it can be used for
inputStream.
• Putting it all together, the following line of code creates a BufferedReader that is
connected to the keyboard:
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
• After this statement executes, br is a character-based stream that is linked to the
console through System.in.

Use a BufferedReader to read characters from the console.
• int read( ) throws IOException : it reads a character from the input stream and
returns it as an integer value.
import java.io.*;
class BRRead {
public static void main(String args[]) throws IOException
{
char c;
BufferedReader br = new
BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter characters, 'q' to quit.");
// read characters
do {
c = (char) br.read();
System.out.println(c);
} while(c != 'q');
}
}
Here is a sample run:
Enter characters, 'q' to
quit.
123abcq
1
2
3
a
b
c
q

Read a string from console using a BufferedReader.
String readLine( ) throws IOException: To read a
string from the keyboard, use the version of
readLine( ) that is a member of the
BufferedReader class.
import java.io.*;
class BRReadLines
{
public static void main(String args[]) throws
IOException
{
// create a BufferedReader using System.in
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
String str;
System.out.println("Enter text.");
System.out.println("Enter 'stop' to quit.");
do {
str = br.readLine();
System.out.println(str);
} while(!str.equals("stop"));
} }
Output:
Enter text.
Enter 'stop' to quit.
abc
abc
xyz
xyz
stop
stop

BufferedWriter Class
BufferedWriter class is used to provide buffering for Writer instances. It makes the
performance fast. It inherits Writer class. The buffering characters are used for providing
the efficient writing of single arrays, characters, and strings.
import java.io.*;
public class BufferedWriterExample {
public static void main(String[] args) throws Exception {
FileWriter writer = new FileWriter("D:testout.txt");
BufferedWriter buffer = new BufferedWriter(writer);
buffer.write("Welcome to File writing.");
buffer.close();
System.out.println("Success");
}
}
Output:
success
A new file testout.txt is created and If you open you will find the below text in the file:
Welcome to File writing.

The PrintWriter Class
• PrintWriter supports the print( ) and println( ) methods for all types
including Object.
• Thus, you can use these methods with System.out.
• If an argument is not a simple type, the PrintWriter methods call the
object’s toString( ) method and then print the result.
• For real-world programs, the recommended method of writing to the
console when using Java is through a PrintWriter stream.
• PrintWriter is one of the character-based classes.
• Using a character-based class for console output makes it easier to
internationalize your program.

Demonstrate PrintWriter
import java.io.*;
public class PrintWriterDemo {
PrintWriter pw = new PrintWriter(System.out);
pw.println("This is a string");
int i = -7;
pw.println(i);
double d = 4.5e-7;
pw.println(d);
} }
The output from this program is shown here:
This is a string
-7
4.5E-7

Java FileInputStream Class
• Java FileInputStream class obtains input bytes from a file. It is used
for reading byte-oriented data (streams of raw bytes) such as image
data, audio, video etc.
• For reading streams of characters, it is recommended to use
FileReader class.
• The declaration for java.io.FileInputStream class:
public class FileInputStream extends InputStream
• Its two most common constructors are shown here:
FileInputStream(String filepath)
FileInputStream(File fileObj)
• Either can throw a FileNotFoundException. Here, filepath is the full
path name of a file, and
• fileObj is a File object that describes the file.

Java FileInputStream Class
import java.io.*;
class ReadFile {
public static void main(String args[]) throws IOException {
//attach the file to FileInputStream
FileInputStream fin= new FileInputStream("file1.txt");
//illustrating getChannel() method
System.out.println(fin.getChannel());
//illustrating getFD() method
System.out.println(fin.getFD());
//illustrating available method
System.out.println("Number of remaining bytes:"+fin.available());
//illustrating skip method
fin.skip(4);
System.out.println("FileContents :");
//read characters from FileInputStream and write them
int ch;
while((ch=fin.read())!=-1)
System.out.print((char)ch);
//close the file
fin.close(); }
ChannelImpl@1db974
java.io.FileDescriptor@10
6d69c
Number of remaining
bytes:38
FileContents :
efgh
ijkl
mnop
qrst
uvwx
yz

FileOutputStream
• Java FileOutputStream is an output stream
used for writing data to a file.
• If you have to write primitive values into a file,
use FileOutputStream class.
• But, for character-oriented data, it is preferred
to use FileWriter.

FileOutputStream
public void write(byte[])throws IOException
import java.io.FileOutputStream;
public class FileOutputStreamExample {
public static void main(String args[]){
try{
FileOutputStream fout=new FileOutputStream("testout.txt");
String s="Welcome to java";
byte b[]=s.getBytes(); //converting string into byte array
fout.write(b);
fout.close();
System.out.println("success...");
}catch(Exception e){System.out.println(e);}
}
}
Output:
Success...
The content of a text file testout.txt is set with the data Welcome to java.
testout.txt
Welcome to java.

Copying files or Reading and Writing Binary Files Using FileInputStream and FileOutputStream
import java.io.*;
public class CopyFilesOne {
if (args.length < 2)
System.out.println("Please provide input and output files");
String inputFile = args[0];
String outputFile = args[1];
try {
InputStream inputStream = new FileInputStream(inputFile);
OutputStream outputStream = new FileOutputStream(outputFile);
long fileSize = new File(inputFile).length();
byte[] allBytes = new byte[(int) fileSize]; // bytearray of input file
inputStream.read(allBytes);
outputStream.write(allBytes);
} catch (IOException ex) {
ex.printStackTrace();
} } }

Files
• The File class is an abstract representation of
file and directory pathname. A pathname can
be either absolute or relative.
• The File class have several methods for
working with directories and files such as
creating new directories or files, deleting and
renaming directories or files, listing the
contents of a directory etc.

Files
• File(File parent, String child): It creates a new File instance
from a parent abstract pathname and a child pathname
string.
• File(String pathname):I t creates a new File instance by
converting the given pathname string into an abstract
pathname.
• File(String parent, String child): It creates a new File
instance from a parent pathname string and a child
pathname string.
• File(URI uri): I t creates a new File instance by converting
the given file: URI into an abstract pathname.

File Class methods program
// Demonstrate File.
import java.io.File;
class FileDemo {
static void p(String s)
{
System.out.println(s);
}
public static void main(String args[])
{
File f1 = new File("/java/COPYRIGHT");
p("File Name: " + f1.getName());
p("Path: " + f1.getPath());
p("Abs Path: " + f1.getAbsolutePath());
p("Parent: " + f1.getParent());
p(f1.exists() ? "exists" : "does not exist");
p(f1.canWrite() ? "is writeable" : "is not writeable");
p(f1.canRead() ? "is readable" : "is not readable");
p("is " + (f1.isDirectory() ? "" : "not" + " a directory"));
p(f1.isFile() ? "is normal file" :
"might be directory");
p("File last modified: " +
f1.lastModified());
p("File size: " + f1.length() + "
Bytes");
} }
Name: COPYRIGHT
Path: /java/COPYRIGHT
Abs Path: c:/java/COPYRIGHT
Parent: /java
exists
is writeable
is readable
is not a directory
is normal file
is absolute
File last modified:
812465204000
File size: 695 Bytes

Serialization and Deserialization in Java
• Serialization is a mechanism of converting the state of an object into a byte
stream.
• Deserialization is the reverse process where the byte stream is used to recreate
the actual Java object in memory. This mechanism is used to persist the object.
• The byte stream created is platform independent. So, the object serialized on one
platform can be deserialized on a different platform.
• To make a Java object serializable we implement java.io.Serializable interface.
• The ObjectOutputStream class contains writeObject() method for serializing an
Object.
public final void writeObject(Object obj) throws IOException.
• The ObjectInputStream class contains readObject() method for deserializing an
object.
public final Object readObject() throws IOException, ClassNotFoundException
• Advantages of Serialization
1. To save/persist state of an object.
2. To travel an object across a network.

• The following code serializes a Demo object to a file named ‘file.txt’.
• And the following code deserializes a Demo object.
Here are some examples of using serialization:
• - Storing data in an object-oriented way to files on disk, e.g. storing a list
of Student objects.
• - Saving program’s states on disk, e.g. saving state of a game.
• - Sending data over the network in form objects, e.g. sending messages as objects
in chat application.

// Java code for serialization and deserialization of a Java object
import java.io.*;
class Demo implements java.io.Serializable {
public int a;
public String b;
// Default constructor
public Demo(int a, String b)
{
this.a = a;
this.b = b;
} }
class Test {
Demo Demoobject = new Demo(1, “CSE-A");
String filename = "file.txt";
// Serialization
try {
//Saving of object in a file
FileOutputStream file = new FileOutputStream(filename);
ObjectOutputStream out = new ObjectOutputStream(file);
// Method for serialization of object
out.writeObject(Demoobject);
out.close();
file.close();
System.out.println("Object has been serialized"); }

catch(IOException ex) { System.out.println("IOException is caught"); }
Demo Demoobject1 = null;
// Deserialization
try {
// Reading the object from a file
FileInputStream file = new FileInputStream(filename);
ObjectInputStream in = new ObjectInputStream(file);
// Method for deserialization of object
Demoobject1 = (Demo)in.readObject();
in.close(); file.close();
System.out.println("Object has been deserialized ");
System.out.println("a = " + Demoobject1.a);
System.out.println("b = " + Demoobject1.b);
} catch(IOException ex) {
System.out.println("IOException is caught"); }
catch(ClassNotFoundException ex)
{ System.out.println("ClassNotFoundException is caught");
} } }
Output:
Object has been serialized
Object has been deserialized
a = 1 b = CSE-A

Primitive Data types and their
Corresponding Wrapper class

value Of() method : We can use valueOf() method to create Wrapper object for given primitive or
String.
public static Wrapper valueOf(String s);
public static Wrapper valueOf(primitive p);
// Java program to illustrate valueof()
class ABC1{
public static void main(String[] args)
{
Integer I = Integer.valueOf(10);
Double D = Double.valueOf(10.5);
Character C = Character.valueOf('a');
System.out.println(I);
System.out.println(D);
System.out.println(C);
}
}
10
10.5
a

• xxxValue() method: We can use xxxValue() methods to get the primitive for
the given Wrapper Object.
• Every number type Wrapper class( Byte, Short, Integer, Long, Float, Double)
contains the following 6 methods to get primitive for the given Wrapper
object:
• public byte byteValue()
• public short shortValue()
• public int intValue()
• public long longValue()
• public float floatValue()
• public float doubleValue()

Java program to illustrate typeValue()
class GFG {
{
Integer I = new Integer(130);
System.out.println(I.shortValue());
System.out.println(I.intValue());
System.out.println(I.longValue());
System.out.println(I.floatValue());
System.out.println(I.doubleValue());
}
}
Output:
130
130
130
130.0
130.0

parseXxx() method : We can use parseXxx()
methods to convert String to primitive.
// Java program to illustrate parseXxx()
class ABC {
{
int i = Integer.parseInt("10");
double d = Double.parseDouble("10.5");
System.out.println(i);
System.out.println(d);
}
}
10
10.5

U-III Prt-2.pptx0 for Java and hardware coding...

More Related Content

Similar to U-III Prt-2.pptx0 for Java and hardware coding... (20)

Recently uploaded (20)

U-III Prt-2.pptx0 for Java and hardware coding...

Editor's Notes