Stream

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.

In java, 3 streams are created for us automatically. All these streams are
attached with console.

1) System.out: standard output stream

2) System.in: standard input stream

3) System.err: standard error stream

Byte Based Character Based

Input Output Input Output
Reader Writer
Basic InputStream OutputStream InputStreamReader OutputS

Arrays ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArra

FileInputStream FileOutputStream
Files RandomAccessFile RandomAccessFile FileReader FileWrite
Pipes PipedInputStream PipedOutputStream PipedReader PipedWri
Buffering BufferedInputStream BufferedOutputStream BufferedReader Buffered
Filtering FilterInputStream FilterOutputStream FilterReader FilterWri
PushbackInputStream PushbackReader
Parsing StreamTokenizer LineNumberReader
Strings StringReader StringWr
Data DataInputStream DataOutputStream
Data –
Formatted PrintStream PrintWrit
Objects ObjectInputStream ObjectOutputStream
Utilities SequenceInputStream

Byte Streams Java byte streams are used to perform input and output of 8-
bit bytes. Though there are many classes related to byte streams but the
most frequently used classes are, FileInputStream and FileOutputStream.
Following is an example which makes use of these two classes to copy an
input file into an output file:

import java.io.*;

public class CopyFile {

public static void main(String args[]) throws IOException

{
 FileInputStream in = null;

FileOutputStream out = null;

try {

in = new FileInputStream("input.txt");

out = new FileOutputStream("output.txt");

int c;

while ((c = in.read()) != -1) {

out.write(c);

}finally {

if (in != null) {

in.close();

if (out != null) {

out.close();

} }

Character Streams Java Byte streams are used to perform input and output
of 8-bit bytes, whereas Java Character streams are used to perform input
and output for 16-bit unicode. Though there are many classes related to
character streams but the most frequently used classes are, FileReader and
FileWriter. Though internally FileReader uses FileInputStream and
FileWriter uses FileOutputStream but here the major difference is that
FileReader reads two bytes at a time and FileWriter writes two bytes at a
time.

import java.io.*;

public class CopyFile {

public static void main(String args[]) throws IOException

 {

FileReader in = null;

FileWriter out = null;

try {

in = new FileReader("input.txt");

out = new FileWriter("output.txt");

int c;

while ((c = in.read()) != -1) {

out.write(c);

}finally {

if (in != null) {

in.close();

if (out != null) {

out.close(); } } } }

import java.io.*;

public class ReadConsole {

public static void main(String args[]) throws IOException

InputStreamReader cin = null;

try {

cin = new InputStreamReader(System.in);

System.out.println("Enter characters, 'q' to quit.");

 char c;

do {

c = (char) cin.read();

System.out.print(c);

} while(c != 'q');

}finally {

if (cin != null) {

cin.close();

Java BufferedInputStream Class

Java BufferedInputStream class is used to read information from stream. It

internally uses buffer mechanism to make the performance fast.

1. import java.io.*;
2. public class BufferedInputStreamExample{
3. public static void main(String args[]){
4. try{
5. FileInputStream fin=new FileInputStream("D:\\testout.txt");
6. BufferedInputStream bin=new BufferedInputStream(fin);
7. int i;
8. while((i=bin.read())!=-1){
9. System.out.print((char)i);
10. }
11. bin.close();
12. fin.close();
13. }catch(Exception e){System.out.println(e);}
14. }
15. }
 UNIT III

XIII EXCEPTION HANDLING IN JAVA

The exception handling in java is one of the powerful mechanism to handle

the runtime errors so that normal flow of the application can be maintained.
Exception is an abnormal condition. Exception Handling is a mechanism to
handle runtime errors
Hierarchy of Java Exception classes

Types of Exception

There are mainly two types of exceptions: checked and unchecked where
error is considered as unchecked exception. The sun microsystem says there
are three types of exceptions:

1. Checked Exception
2. Unchecked Exception
3. Error

Difference between checked and unchecked exceptions

1) Checked Exception
The classes that extend Throwable class except RuntimeException and Error
are known as checked exceptions e.g.IOException, SQLException etc.
Checked exceptions are checked at compile-time.

2) Unchecked Exception

The classes that extend RuntimeException are known as unchecked

exceptions e.g. ArithmeticException, NullPointerException,
ArrayIndexOutOfBoundsException etc. Unchecked exceptions are not
checked at compile-time rather they are checked at runtime.

3) Error

Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError,

AssertionError etc.

Java Exception Handling Keywords

There are 5 keywords used in java exception handling.

1. Try catch finally throw throws

Java try-catch

Java try block

Java try block is used to enclose the code that might throw an exception. It
must be used within the method.

Java try block must be followed by either catch or finally block.

Syntax of java try-catch

1. try{
2. //code that may throw exception
3. }catch(Exception_class_Name ref){}

1. public class Testtrycatch2{

2. public static void main(String args[]){
3. try{
4. int data=50/0;
5. }catch(ArithmeticException e){System.out.println(e);}
6. System.out.println("rest of the code...");
7. }
8. }
Java Multi catch block

If you have to perform different tasks at the occurrence of different

Exceptions, use java multi catch block.

Let's see a simple example of java multi-catch block.

1. public class TestMultipleCatchBlock{

2. public static void main(String args[]){
3. try{
4. int a[]=new int[5];
5. a[5]=30/0;
6. }
7. catch(ArithmeticException e){System.out.println("task1 is completed
");}
8. catch(ArrayIndexOutOfBoundsException e){System.out.println("task
2 completed");}
9. catch(Exception e){System.out.println("common task completed");}
10.
11. System.out.println("rest of the code...");
12. }
13. }

Java finally block

Java finally block is a block that is used to execute important code such as
closing connection, stream etc.

Java finally block is always executed whether exception is handled or not.

Java finally block follows try or catch block.

Why use java finally

 Finally block in java can be used to put "cleanup" code such as

closing a file, closing connection etc.

Case 1

Let's see the java finally example where exception doesn't occur.

1. class TestFinallyBlock{
2. public static void main(String args[]){
3. try{
 4. int data=25/5;
5. System.out.println(data);
6. }
7. catch(NullPointerException e){System.out.println(e);}
8. finally{System.out.println("finally block is always executed");}
9. System.out.println("rest of the code...");
10. }
11. }

Case 3

Let's see the java finally example where exception occurs and handled.

1. public class TestFinallyBlock2{

2. public static void main(String args[]){
3. try{
4. int data=25/0;
5. System.out.println(data);
6. }
7. catch(ArithmeticException e){System.out.println(e);}
8. finally{System.out.println("finally block is always executed");}
9. System.out.println("rest of the code...");
10. }
11. }

Java throw keyword

The Java throw keyword is used to explicitly throw an exception.

We can throw either checked or uncheked exception in java by throw

keyword. The throw keyword is mainly used to throw custom exception. We
will see custom exceptions later.

The syntax of java throw keyword is given below.

1. throw exception;

1. public class TestThrow1{

2. static void validate(int age){
3. if(age<18)
4. throw new ArithmeticException("not valid");
5. else
6. System.out.println("welcome to vote");
7. }
8. public static void main(String args[]){
9. validate(13);
10. System.out.println("rest of the code...");
 11. }
12. }

Java throws keyword

The Java throws keyword is used to declare an exception. It gives an

information to the programmer that there may occur an exception so it is
better for the programmer to provide the exception handling code so that
normal flow can be maintained.

Exception Handling is mainly used to handle the checked exceptions. If

there occurs any unchecked exception such as NullPointerException, it is
programmers fault that he is not performing check up before the code being
used.

Syntax of java throws

1. return_type method_name() throws exception_class_name{

2. //method code
3. }

import java.io.*;
class M{
void method()throws IOException{
throw new IOException("device error");
} }
public class Testthrows2{
public static void main(String args[]){
try{
M m=new M();
m.method();
}catch(Exception e){System.out.println("exception handled");}
System.out.println("normal flow...");
} }

Java Custom Exception

If you are creating your own Exception that is known as custom exception or
user-defined exception. Java custom exceptions are used to customize the
exception according to user need.

Let's see a simple example of java custom exception.

1. class InvalidAgeException extends Exception{

2. InvalidAgeException(String s){
 3. super(s);
4. }
5. }

1. class TestCustomException1{
2.
3. static void validate(int age)throws InvalidAgeException{
4. if(age<18)
5. throw new InvalidAgeException("not valid");
6. else
7. System.out.println("welcome to vote");
8. }
9.
10. public static void main(String args[]){
11. try{
12. validate(13);
13. }catch(Exception m){System.out.println("Exception occured:
"+m);}
14.
15. System.out.println("rest of the code..."); }}

XIV MULTI THREADING IN JAVA

Multithreading in java is a process of executing multiple threads

simultaneously. Thread is basically a lightweight sub-process, a smallest
unit of processing. Multiprocessing and multithreading, both are used to
achieve multitasking.

Advantages of Java Multithreading

1) It doesn't block the user because threads are independent and you can
perform multiple operations at same time.

2) You can perform many operations together so it saves time.

3) Threads are independent so it doesn't affect other threads if exception

occur in a single thread.

What is Thread in java

A thread is a lightweight sub process, a smallest unit of processing. It is a

separate path of execution.
Threads are independent, if there occurs exception in one thread, it doesn't
affect other threads. It shares a common memory area.

Life cycle of a Thread (Thread States)

1. New
2. Runnable
3. Running
4. Non-Runnable (Blocked)
5. Terminated

A thread can be in one of the five states. According to sun, there is only 4
states in thread life cycle in java new, runnable, non-runnable and
terminated. There is no running state.

But for better understanding the threads, we are explaining it in the 5

states.

The life cycle of the thread in java is controlled by JVM.

The java thread states are as follows:

1. New
2. Runnable
3. Running
4. Non-Runnable (Blocked)
5. Terminated
 1) New

The thread is in new state if you create an instance of Thread class but
before the invocation of start() method.
2) Runnable

The thread is in runnable state after invocation of start() method, but the
thread scheduler has not selected it to be the running thread.

3) Running

The thread is in running state if the thread scheduler has selected it.

4) Non-Runnable (Blocked)

This is the state when the thread is still alive, but is currently not eligible to
run.

5) Terminated

A thread is in terminated or dead state when its run() method exits.

How to create thread

There are two ways to create a thread:

1. By extending Thread class

2. By implementing Runnable interface.

Thread class:
Thread class provide constructors and methods to create and perform
operations on a thread. Thread class extends Object class and implements
Runnable interface.

Commonly used Constructors of Thread class:

 Thread()
 Thread(String name)
 Thread(Runnable r)
 Thread(Runnable r,String name)

Commonly used methods of Thread class:

public void run(): is used to perform action for a thread.

public void start(): starts the execution of the thread.JVM calls the
run() method on the thread.

public void sleep(long miliseconds): Causes the currently executing

thread to sleep (temporarily cease execution) for the specified number
of milliseconds.

public void join(): waits for a thread to die.

public void join(long miliseconds): waits for a thread to die for the
specified miliseconds.

public int getPriority(): returns the priority of the thread.

public int setPriority(int priority): changes the priority of the

thread.

public String getName(): returns the name of the thread.

public void setName(String name): changes the name of the thread.

public Thread currentThread(): returns the current thread.

public int getId(): returns the id of the thread.

 public Thread.State getState(): returns the state of the thread.

public boolean isAlive(): tests if the thread is alive.

public void yield(): causes the currently executing thread object to

temporarily pause and allow other threads to execute.

public void suspend(): is used to suspend the thread(depricated).

public void resume(): is used to resume the suspended

thread(depricated).

public void stop(): is used to stop the thread(depricated).

public boolean isDaemon(): tests if the thread is a daemon thread.

public void setDaemon(boolean b): marks the thread as daemon or

user thread.

public void interrupt(): interrupts the thread.

public boolean isInterrupted(): tests if the thread has been

interrupted.

public static boolean interrupted(): tests if the current thread has

been interrupted.
Runnable interface:
The Runnable interface should be implemented by any class whose
instances are intended to be executed by a thread. Runnable interface have
only one method named run().

1. public void run(): is used to perform action for a thread.

Starting a thread:
start() method of Thread class is used to start a newly created thread. It
performs following tasks:

 A new thread starts(with new callstack).

 The thread moves from New state to the Runnable state.
 When the thread gets a chance to execute, its target run() method will
run.

1) Java Thread Example by extending Thread class

1. class Multi extends Thread{

2. public void run(){
3. System.out.println("thread is running...");
 4. }
5. public static void main(String args[]){
6. Multi t1=new Multi();
7. t1.start();
8. }
9. }

2) Java Thread Example by implementing Runnable

interface

1. class Sample implements Runnable{

2. public void run(){
3. System.out.println("Thread is running...");
4. }
5.
6. public static void main(String args[]){
7. Sample s=new Sample();
8. Thread t1 =new Thread(s);
9. t1.start();
10. }
11. }

Sleep method in java

The sleep() method of Thread class is used to sleep a thread for the specified
amount of time.

Syntax of sleep() method in java

The Thread class provides two methods for sleeping a thread:

 public static void sleep(long miliseconds)throws InterruptedException

 public static void sleep(long miliseconds, int nanos)throws
InterruptedException

Example of sleep method in java

1. class Ex extends Thread{

2. public void run(){
3. for(int j=1;j<5;j++){
4. try{Thread.sleep(500);}catch(InterruptedException e){System.out.pri
ntln(e);}
5. System.out.println(j);
 6. }
7. }
8. public static void main(String args[]){
9. Ex t1=new Ex();
10. Ex t2=new Ex();
11.
12. t1.start();
13. t2.start();
14. }
15. }

The join() method

The join() method waits for a thread to die. In other words, it causes the
currently running threads to stop executing until the thread it joins with
completes its task.

Syntax:
public void join()throws InterruptedException

public void join(long milliseconds)throws InterruptedException

Example of join() method

1. class Sample extends Thread{

2. public void run(){
3. for(int i=1;i<=5;i++){
4. try{
5. Thread.sleep(500);
6. }catch(Exception e){System.out.println(e);}
7. System.out.println(i);
8. } }
9. public static void main(String args[]){
10. Sample t1=new Sample ();
11. Sample t2=new Sample ();
12. Sample t3=new Sample ();
13. t1.start();
14. try{
15. t1.join();
16. }catch(Exception e){System.out.println(e);}
17. t2.start();
18. t3.start();
19. } }

getName(),setName(String) and getId() method:

public String getName()

public void setName(String name)

public long getId()

1. class Sample1 extends Thread{

2. public void run(){
3. System.out.println("running...");
4. }
5. public static void main(String args[]){
6. Sample1t1=new Sample1 ();
7. Sample1 t2=new Sample1 ();
8. System.out.println("Name of t1:"+t1.getName());
9. System.out.println("Name of t2:"+t2.getName());
10. System.out.println("id of t1:"+t1.getId());
11. t1.start();
12. t2.start();
13. t1.setName("Sonoo Jaiswal");
14. System.out.println("After changing name of t1:"+t1.getName());

15. }}

Priority of a Thread (Thread Priority):

Each thread have a priority. Priorities are represented by a number between
1 and 10. In most cases, thread schedular schedules the threads according
to their priority (known as preemptive scheduling). But it is not guaranteed
because it depends on JVM specification that which scheduling it chooses.

3 constants defined in Thread class:

1. public static int MIN_PRIORITY
2. public static int NORM_PRIORITY
3. public static int MAX_PRIORITY

Default priority of a thread is 5 (NORM_PRIORITY). The value of

MIN_PRIORITY is 1 and the value of MAX_PRIORITY is 10.
 Example of priority of a Thread:

1. class TestMultiPriority1 extends Thread{

2. public void run(){
3. System.out.println("running thread name is:"+Thread.currentThread
().getName());
4. System.out.println("running thread priority is:"+Thread.currentThre
ad().getPriority());
5.
6. }
7. public static void main(String args[]){
8. TestMultiPriority1 m1=new TestMultiPriority1();
9. TestMultiPriority1 m2=new TestMultiPriority1();
10. m1.setPriority(Thread.MIN_PRIORITY);
11. m2.setPriority(Thread.MAX_PRIORITY);
12. m1.start();
13. m2.start();
14.
15. }
16. }

ThreadGroup in Java

Java provides a convenient way to group multiple threads in a single object.

In such way, we can suspend, resume or interrupt group of threads by a
single method call.

Constructors of ThreadGroup class

There are only two constructors of ThreadGroup class.

No. Constructor Description

creates a thread group with given
1) ThreadGroup(String name)
name.
ThreadGroup(ThreadGroup parent, creates a thread group with given
2)
String name) parent group and name.
ThreadGroup Example

File: ThreadGroupDemo.java

1. public class ThreadGroupDemo implements Runnable{

2. public void run()
3. {
4. System.out.println(Thread.currentThread().getName());
5. }
6. public static void main(String[] args)
7. {
8. ThreadGroupDemo runnable = new ThreadGroupDemo();
9. ThreadGroup tg1 = new ThreadGroup("Parent ThreadGroup");
10.
11. Thread t1 = new Thread(tg1, runnable,"one");
12. t1.start();
13. Thread t2 = new Thread(tg1, runnable,"two");
14. t2.start();
15. Thread t3 = new Thread(tg1, runnable,"three");
16. t3.start();
17.
18. System.out.println("Thread Group Name: "+tg1.getName()
);
19. tg1.list();
20.
21. }
22. }

1. class TestMultitasking1 extends Thread{

2. public void run(){
3. System.out.println("task one");
4. }
5. public static void main(String args[]){
6. TestMultitasking1 t1=new TestMultitasking1();
7. TestMultitasking1 t2=new TestMultitasking1();
8. TestMultitasking1 t3=new TestMultitasking1();
9.
10. t1.start();
11. t2.start();
12. t3.start();
13. }
14. }

Synchronization in Java

Synchronization in java is the capability to control the access of multiple

threads to any shared resource.
Java Synchronization is better option where we want to allow only one
thread to access the shared resource.

Why use Synchronization

The synchronization is mainly used to

1. To prevent thread interference.

2. To prevent consistency problem.

Types of Synchronization

There are two types of synchronization

1. Process Synchronization
2. Thread Synchronization

Thread Synchronization

There are two types of thread synchronization mutual exclusive and inter-
thread communication.

1. Mutual Exclusive
1. Synchronized method.
2. Synchronized block.
3. static synchronization.
2. Cooperation (Inter-thread communication in java)

Mutual Exclusive

Mutual Exclusive helps keep threads from interfering with one another while
sharing data. This can be done by three ways in java:

1. by synchronized method
2. by synchronized block
3. by static synchronization

Concept of Lock in Java

Synchronization is built around an internal entity known as the lock or

monitor. Every object has an lock associated with it. By convention, a thread
that needs consistent access to an object's fields has to acquire the object's
lock before accessing them, and then release the lock when it's done with
them.

From Java 5 the package java.util.concurrent.locks contains several lock

implementations.
 1. //example of java synchronized method
2. class Table{
3. synchronized void printTable(int n){//synchronized method
4. for(int i=1;i<=5;i++){
5. System.out.println(n*i);
6. try{
7. Thread.sleep(400);
8. }catch(Exception e){System.out.println(e);}
9. }
10.
11. }
12. }
13.
14. class MyThread1 extends Thread{
15. Table t;
16. MyThread1(Table t){
17. this.t=t;
18. }
19. public void run(){
20. t.printTable(5);
21. }
22.
23. }
24. class MyThread2 extends Thread{
25. Table t;
26. MyThread2(Table t){
27. this.t=t;
28. }
29. public void run(){
30. t.printTable(100);
31. }
32. }
33.
34. public class TestSynchronization2{
35. public static void main(String args[]){
36. Table obj = new Table();//only one object
37. MyThread1 t1=new MyThread1(obj);
38. MyThread2 t2=new MyThread2(obj);
39. t1.start();
40. t2.start();
41. }
42. }

Inter-thread communication in Java

Inter-thread communication or Co-operation is all about allowing

synchronized threads to communicate with each other.
Cooperation (Inter-thread communication) is a mechanism in which a
thread is paused running in its critical section and another thread is
allowed to enter (or lock) in the same critical section to be executed.It is
implemented by following methods of Object class:

 wait()
 notify()
 notifyAll()

1) wait() method

Causes current thread to release the lock and wait until either another
thread invokes the notify() method or the notifyAll() method for this object,
or a specified amount of time has elapsed.

The current thread must own this object's monitor, so it must be called from
the synchronized method only otherwise it will throw exception.

Method Description

public final void wait()throws

waits until object is notified.
InterruptedException

public final void wait(long timeout)throws waits for the specified

InterruptedException amount of time.

2) notify() method

Wakes up a single thread that is waiting on this object's monitor. If any

threads are waiting on this object, one of them is chosen to be awakened.
The choice is arbitrary and occurs at the discretion of the implementation.
Syntax:

public final void notify()

3) notifyAll() method

Wakes up all threads that are waiting on this object's monitor. Syntax:

public final void notifyAll()

UNIT IV