CS 1303 Object Oriented Programming Department of CSE

UNIT III EXCEPTIONS, COLLECTIONS AND STREAMS

Exceptions – exception hierarchy – throwing and catching exceptions – built-in exceptions, creating
own exceptions, Stack Trace Elements. Input / Output Basics – Streams – Byte streams and
Character streams – Reading and Writing Console – Reading and Writing Files.

Error
 Error is a critical condition that cannot be handled by the code of the program.
 An error is caused due to lack of system resources.
 Errors are unchecked type. They are checked at runtime.eg. OutOfMemoryError
Exception
 An Exception is an unwanted event that interrupts the normal flow of the program. When an
exception occurs program execution gets terminated.
 Exception is the exceptional situation that can be handled by the code of the program.
 An exception is caused because of the code.
Types

1) Checked ExceptionThe classes that extend Throwable class 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.

Hierarchy of Java Exception classes

All exception and errors types are sub classes of class Throwable

St. Joseph’s College of Engineering Page 1 of 20

CS 1303 Object Oriented Programming Department of CSE
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

There are 5 keywords used in java exception handling.

1. try
2. catch
3. finally
4. throw
5. throws

try-catch block:

 The try block contains set of statements where an exception can occur.
 A try block must be followed by catch blocks or finally block or both.
 Java catch block is used to handle the Exception.

Syntax

try {
// Protected code
} catch (ExceptionName e1) {
// Catch block
}
Example 1:
import java.io.*;
public class ExcepTest {

public static void main(String args[]) {

try {
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
Output:
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Example2:
class JavaException {
public static void main(String args[]) {
int d = 0;
St. Joseph’s College of Engineering Page 2 of 20
CS 1303 Object Oriented Programming Department of CSE
int n = 20;
try {
int fraction = n / d;
System.out.println("This line will not be Executed");
} catch (ArithmeticException e) {
System.out.println("In the catch Block due to Exception = " + e);
}
System.out.println("End Of Main");
}
}

Multi catch block

class Example2{
public static void main(String args[]){
try{
int a[]=new int[7];
a[4]=30/0;
System.out.println("First print statement in try block");
}
catch(ArithmeticException e){
System.out.println("Warning: ArithmeticException");
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("Warning: ArrayIndexOutOfBoundsException");
}
catch(Exception e){
System.out.println("Warning: Some Other exception");
}
System.out.println("Out of try-catch block...");
}
}
Output:

Warning: ArithmeticException
Out of try-catch block...

throw Keyword
throw keyword is used to throw an exception explicitly. Only object of Throwable class or its sub
classes can be thrown. Program execution stops on encountering throw statement, and the closest catch
statement is checked for matching type of exception.

Syntax :

throw ThrowableInstance

class Test
{
static void avg()

St. Joseph’s College of Engineering Page 3 of 20

CS 1303 Object Oriented Programming Department of CSE
{
try
{
throw new ArithmeticException("demo");
}
catch(ArithmeticException e)
{
System.out.println("Exception caught");
}
}

public static void main(String args[])

{
avg();
}
}

throws Keyword
Any method that is capable of causing exceptions must list all the exceptions possible during its
execution, so that anyone calling that method gets a prior knowledge about which exceptions are to be
handled. A method can do so by using the throws keyword.

Syntax :

type method_name(parameter_list) throws exception_list

{
//definition of method
}

Example:
class Test
{
static void check() throws ArithmeticException
{
System.out.println("Inside check function");
throw new ArithmeticException("demo");
}

public static void main(String args[])

{
try
{
check();
}
catch(ArithmeticException e)
{
System.out.println("caught" + e);
} }}

St. Joseph’s College of Engineering Page 4 of 20

CS 1303 Object Oriented Programming Department of CSE
Output:
Inside check function
caughtjava.lang.ArithmeticException: demo
finally
 Java finally block is always executed whether exception is handled or not. Java finally block
follows try or catch block.
 A finally keyword is used to create a block of code that follows a try block.
 Finally block in java can be used to put "cleanup" code such as closing a file, closing connection
etc.
Output:
class TestFinallyBlock1{
public static void main(String args[]){
try{
int data=25/0;
System.out.println(data);
}
catch(NullPointerException e){System.out.println(e);}
finally{System.out.println("finally block is always executed");}
System.out.println("rest of the code...");
}
}
Output:
finally block is always executed
Exception in thread main java.lang.ArithmeticException:/ by zero

Built-in exceptions
Built-in exceptions are the exceptions which are available in Java libraries. These exceptions are
suitable to explain certain error situations.
Java defines several other types of exceptions that relate to its various class libraries. Following is the list
of Java Unchecked RuntimeException.

Sr.No. Exception & Description

1 ArithmeticException
Arithmetic error, such as divide-by-zero.

2 ArrayIndexOutOfBoundsException
Array index is out-of-bounds.

3 ArrayStoreException
Assignment to an array element of an incompatible type.

4 ClassCastException
Invalid cast.

5 IllegalArgumentException

St. Joseph’s College of Engineering Page 5 of 20

CS 1303 Object Oriented Programming Department of CSE
Illegal argument used to invoke a method.

6 IllegalMonitorStateException
Illegal monitor operation, such as waiting on an unlocked thread.

7 IllegalStateException
Environment or application is in incorrect state.

8 IllegalThreadStateException
Requested operation not compatible with the current thread state.

9 IndexOutOfBoundsException
Some type of index is out-of-bounds.

10 NegativeArraySizeException
Array created with a negative size.

11 NullPointerException
Invalid use of a null reference.

12 NumberFormatException
Invalid conversion of a string to a numeric format.

13 SecurityException
Attempt to violate security.

14 StringIndexOutOfBounds
Attempt to index outside the bounds of a string.

15 UnsupportedOperationException
An unsupported operation was encountered.

Following is the list of Java Checked Exceptions Defined in java.lang.

Sr.No. Exception & Description

1 ClassNotFoundException
Class not found.

2 CloneNotSupportedException
Attempt to clone an object that does not implement the Cloneable interface.

3 IllegalAccessException
Access to a class is denied.

4 InstantiationException
Attempt to create an object of an abstract class or interface.

5 InterruptedException
One thread has been interrupted by another thread.

St. Joseph’s College of Engineering Page 6 of 20

CS 1303 Object Oriented Programming Department of CSE
6 NoSuchFieldException
A requested field does not exist.

7 NoSuchMethodException
A requested method does not exist.

Example:
ClassNotFoundException : This Exception is raised when we try to access a class whose definition is
not found.
// Java program to illustrate the
// concept of ClassNotFoundException
class Bishal {

} class Geeks {

} class MyClass {
public static void main(String[] args)
{
Object o = class.forName(args[0]).newInstance();
System.out.println("Class created for" + o.getClass().getName());
}
}
Output:
ClassNotFoundException

FileNotFoundException :
This Exception is raised when a file is not accessible or does not open.
// Java program to demonstrate
// FileNotFoundException
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
class File_notFound_Demo {
public static void main(String args[])
{
try {

// Following file does not exist

File file = new File("E:// file.txt");

FileReader fr = new FileReader(file);

}
catch (FileNotFoundException e) {
System.out.println("File does not exist");
} }}
Output:
File does not exist

St. Joseph’s College of Engineering Page 7 of 20

CS 1303 Object Oriented Programming Department of CSE

NullPointerException :
This exception is raised when referring to the members of a null object. Null represents nothing
// Java program to demonstrate NullPointerException
class NullPointer_Demo {
public static void main(String args[])s
{
try {
String a = null; // null value
System.out.println(a.charAt(0));
}
catch (NullPointerException e) {
System.out.println("NullPointerException..");
}
}
}
Output:
NullPointerException..

NumberFormatException : This exception is raised when a method could not convert a string into a
numeric format.
// Java program to demonstrate
// NumberFormatException
class NumberFormat_Demo {
public static void main(String args[])
{
try {
// "akki" is not a number
int num = Integer.parseInt("akki");

System.out.println(num);
}
catch (NumberFormatException e) {
System.out.println("Number format exception");
}
}
}
Output:
Number format exception

User Defined Exception

 In java we can create our own exception class and throw that exception using throw keyword.
These exceptions are known as user-defined or custom exceptions.
 Extend the Exception class to create your own exception class.
Example:
class MyException extends Exception{
String str1;
MyException(String str2) {
str1=str2;

St. Joseph’s College of Engineering Page 8 of 20

CS 1303 Object Oriented Programming Department of CSE
}
public String toString(){
return ("MyException Occurred: "+str1) ;
}
}

class Example1{
public static void main(String args[]){
try{
System.out.println("Starting of try block");
// I'm throwing the custom exception using throw
throw new MyException("This is My error Message");
}
catch(MyException exp){
System.out.println("Catch Block") ;
System.out.println(exp) ;
}
}
}

Output:
Starting of try block
Catch Block
MyException Occurred: This is My error Message

Stack Trace
Stack Trace is a list of method calls from the point when the application was started to the point
where the exception was thrown. The most recent method calls are at the top.
StackTraceElement
An element in a stack trace, as returned by Throwable.getStackTrace(). Each element represents a
single stack frame. All stack frames except for the one at the top of the stack represent a method
invocation. The frame at the top of the stack represents the execution point at which the stack trace was
generated.
stack frame representation: (Constructor of StackTraceElement class)
StackTraceElement(String declaringClass, String methodName, String fileName,
intlineNumber);

Example:

public class StackTraceExample

{
public static void main(String[] args)
{
method1();
}

public static void method1() {

method11();
}

St. Joseph’s College of Engineering Page 9 of 20

CS 1303 Object Oriented Programming Department of CSE

public static void method11() {

method111();
}
public static void method111() {
try
{
throw new NullPointerException("Fictitious NullPointerException");
}
Catch(NullPointerException e)
{
e.printstackmethod();
}
}
Output
Fictitious NullPointerException
at StackTraceExample.method111(StackTraceExample.java:15)
at StackTraceExample.method11(StackTraceExample.java:11)
at StackTraceExample.method1(StackTraceExample.java:7)
atStackTraceExample.main(StackTraceExample.java:3)

Method of StackTraceElementclass

 String getClassName(): Returns the class name of the execution point described by the invoking
StackTraceElement
 String getFileName(): Returns the file name of the execution point described by the invoking
StackTraceElement.
 intgetLineNumber(): Returns the source-code line number of the execution point described by
the invoking StackTraceElement.
 String getMethodName(): Returns the method name of the execution point described by the
invoking StackTraceElement.
 boolean equals(ob):
Returns try if the invoking StackTraceElement is as the one passed in ob. Otherwise it returns
false.
Syntax: public booleanequals(ob)
Returns: true if the specified object is
anotherStackTraceElement instance representing the same execution point as this instance.

// Java code illustrating equals() method

importjava.lang.*;
import java.io.*;
importjava.util.*;
public class StackTraceElementDemo {
public static void main(String[] arg)
{
StackTraceElement st1 = new StackTraceElement("foo", "fuction1",
"StackTrace.java", 1);
StackTraceElement st2 = new StackTraceElement("bar", "function2",

St. Joseph’s College of Engineering Page 10 of 20

CS 1303 Object Oriented Programming Department of CSE
"StackTrace.java", 1);
Object ob = st1.getFileName();
// checking whether file names are same or not
System.out.println(st2.getFileName().equals(ob)); } }
Output:true

Nested Try
Exception handlers can be nested within one another. A try, catch or a finally block can in turn contains
another set of try catch finally sequence. In such a scenario, when a particular catch block is unable to
handle an Exception, this exception is rethrown. This exception would be handled by the outer set of try
catch handler. Look at the following code for Example.

import java.util.InputMismatchException;
public class Nested {
public static void main(String[] args) {
try {
System.out.println("Outer try block starts");
try {
System.out.println("Inner try block starts");
int res = 5 / 0;
} catch (InputMismatchException e) {
System.out.println("InputMismatchException caught");
} finally {
System.out.println("Inner final");
}
} catch (ArithmeticException e) {
System.out.println("ArithmeticException caught");
} finally {
System.out.println("Outer finally");
}
}
}

Output

Outer try block starts

Inner try block starts
Inner final
ArithmeticException caught
Outer finally Outer finally

Reading and Writing from console.

 The Java Console class is be used to get input from console. It provides methods to read texts and
passwords.
 If you read password using Console class, it will not be displayed to the user.
 The java.io.Console class is attached with system console internally.

St. Joseph’s College of Engineering Page 11 of 20

CS 1303 Object Oriented Programming Department of CSE
Java Console class methods
Method Description

Reader reader() It is used to retrieve the reader object

associated with the console

String readLine() It is used to read a single line of text from the console.

String readLine(String fmt, It provides a formatted prompt then reads the single line of text
Object... args) from the console.

char[] readPassword() It is used to read password that is not being displayed on the
console.

char[] readPassword(String fmt, It provides a formatted prompt then reads the password that is not
Object... args) being displayed on the console.

Console format(String fmt, It is used to write a formatted string

Object... args) to the console output stream.

Console printf(String format, It is used to write a string to the console output stream.
Object... args)

PrintWriter writer() It is used to retrieve the PrintWriter

object associated with the console.

void flush() It is used to flushes the console.

1.1. Reading Input with readLine()

Console console = System.console();
if(console == null) {
System.out.println("Console is not available to current JVM process");
return;
}

String userName = console.readLine("Enter the username: ");

System.out.println("Entered username: " + userName);
Program output

Enter the username: lokesh

Entered username: Lokesh

1.2. Reading Input with readPassword()

Console console = System.console();

if(console == null) {
System.out.println("Console is not available to current JVM process");
return;

St. Joseph’s College of Engineering Page 12 of 20

CS 1303 Object Oriented Programming Department of CSE
}

char[] password = console.readPassword("Enter the password: ");

System.out.println("Entered password: " + new String(password));
Program output

Enter the password: //input will not visible in the console

Entered password: passphrase

1.3. Read Input with reader()

Console console = System.console();

if(console == null) {
System.out.println("Console is not available to current JVM process");
return;
}

Reader consoleReader = console.reader();

Scanner scanner = new Scanner(consoleReader);

System.out.println("Enter age:");
int age = scanner.nextInt();
System.out.println("Entered age: " + age);

scanner.close();
Program output

Enter age:
12
Entered age: 12

2. Writing Output to Console

The easiest way to write the output data to console is System.out.println() statements. Still, we can use
printf() methods to write formatted text to console.

2.1. Writing with System.out.println

System.out.println("Hello, world!");
Program output
Hello, world!

2.2. Writing with printf()

The printf(String format, Object... args) method takes an output string and multiple parameters which
are substituted in the given string to produce the formatted output content. This formatted output is
written in the console.

String name = "Lokesh";

int age = 38;

console.printf("My name is %s and my age is %d", name, age);

St. Joseph’s College of Engineering Page 13 of 20

CS 1303 Object Oriented Programming Department of CSE
Program output
My name is Lokesh and my age is 38

Input/output streams in java

A stream can be defined as a sequence of data. Java encapsulates Stream under java.io package.
There are two kinds of Streams
Types of stream classes:
 Byte Stream
 Character Stream

Byte Stream

Byte stream classes are used to perform reading and writing of 8-bit bytes. All byte stream classes are
descended from InputStream and OutputStream.

Byte stream classes.

Stream class Description

BufferedInputStream Used for Buffered Input Stream.

BufferedOutputStream Used for Buffered Output Stream.

DataInputStream Contains method for reading java standard datatype

DataOutputStream An output stream that contain method for writing java

standard data type

FileInputStream Input stream that reads from a file

FileOutputStream Output stream that write to a file.

InputStream Abstract class that describe stream input.

OutputStream Abstract class that describe stream output.

PrintStream Output Stream that contain print() and println() method

Methods of InputStream class.

These methods are inherited by InputStream subclasses.

Methods Description
This method returns the number of bytes that can be read
int available()
from the input stream.
abstract int read() This method reads the next byte out of the input stream.

St. Joseph’s College of Engineering Page 14 of 20

CS 1303 Object Oriented Programming Department of CSE
This method reads a chunk of bytes from the input stream and
int read(byte[] b)
store them in its byte array, b.
This method closes this output stream and also frees any
close()
resources connected with this output stream.

Methods of OutputStream class.

Methods Description
This method flushes the output steam by forcing out buffered
flush()
bytes to be written out.
This method writes byte(contained in an int) to the output
abstract write(int c)
stream.
write(byte[] b) This method writes a whole byte array(b) to the output.
This method closes this output stream and also frees any
close()
resources connected with this output stream.

Read the data from the keyboard:

public class KeyboardReading
{
public static void main(String args[]) throws IOException
{
DataInputStream dis = new DataInputStream(System.in);
System.out.println("Enter your name: ");
String str1 = dis.readLine();
System.out.println(" name is " + str1);

System.out.println("Enter the number: ");

String str2 = dis.readLine();
int x = Integer.parseInt(str2);
System.out.println(" number is " + x);
}
Write the data to the console
write(bytes[]) method used to write a sequence of characters to the console:

Example
/*
Write character sequence to the console
*/
import java.io.IOException; // Import the IOException class from java.io package

class WriteToConsole {
public static void main(String[] args) {
try {
byte consoleOut[] = new byte[]{'J','a','v','a',};
System.out.write(consoleOut);
}
catch (IOException ex) {
St. Joseph’s College of Engineering Page 15 of 20
CS 1303 Object Oriented Programming Department of CSE
System.out.println("Caught IOException: " + ex);
}
}
}

Reading and writing files

Example for FileInputStream and FileOutputStream class:

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((char)c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
} } }}

Example:
import java.io.*;
public class BufferedInputStreamExample{
public static void main(String args[]){
try{
FileInputStream fin=new FileInputStream("D:\\testout.txt");
BufferedInputStream bin=new BufferedInputStream(fin);
int i;
while((i=bin.read())!=-1){
System.out.print((char)i);
}
bin.close();
fin.close();
}catch(Exception e){System.out.println(e);} } }

St. Joseph’s College of Engineering Page 16 of 20

CS 1303 Object Oriented Programming Department of CSE
Character Stream
It provides a convenient means for handling input and output of characters. Character stream
uses Unicode and therefore can be internationalized. All character stream classes are descended from
Reader and Writer class.

Important Charcter stream classes.

Stream class Description

BufferedReader Handles buffered input stream.

BufferedWriter Handles buffered output stream.

FileReader Input stream that reads from file.

FileWriter Output stream that writes to file.

InputStreamReader Input stream that translate byte to character

OutputStreamReader Output stream that translate character to byte.

PrintWriter Output Stream that

contain print() and println() method.

Reader Abstract class that define character stream input

Writer Abstract class that define character stream

output

Methods of Reader class.

Methods Description
int read() This method reads a characters from the input stream.
int read(char[] This method reads a chunk of characters from the input stream and store them
ch) in its char array, ch.
This method closes this output stream and also frees any system resources
close()
connected with it.
Methods of writer class
Methods Description
This method flushes the output steam by forcing out buffered
abstract void flush()
bytes to be written out.
This method writes a characters(contained in an int) to the
void write(int c)
output stream.
This method writes a whole char array(arr) to the output
void write(char[] arr)
stream.
This method closes this output stream and also frees any
abstract void close()
resources connected with this output stream.

St. Joseph’s College of Engineering Page 17 of 20

CS 1303 Object Oriented Programming Department of CSE
Reading and writing file
Example:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedReaderWriterExample {

public static void main(String[] args) {
File file = new File("file.txt");

/*Writing file using BufferedWriter*/

FileWriter fwr = null;
BufferedWriter bwr =null;
try {
fwr =new FileWriter(file);
bwr =new BufferedWriter(fwr);
bwr.write("This is an example \n");
bwr.write("of using BufferedWriter and \n");
bwr.write("BufferedReader.");
bwr.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fwr!=null){
fwr.close();
}
if(bwr!=null){
bwr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}

/*Reading file using BufferedReader*/

FileReader fr=null;
BufferedReader br=null;
try {
fr =new FileReader(file);
br=new BufferedReader(fr);
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
} catch (IOException e) {

St. Joseph’s College of Engineering Page 18 of 20

CS 1303 Object Oriented Programming Department of CSE
e.printStackTrace();
}finally {
try {
if(fr!=null){
fr.close();
}
if(br!=null){
br.close();
}
} catch (IOException e) {
e.printStackTrace();
} } }}
Output (file.txt):
This is an example
of using BufferedWriter and
BufferedReader.

Reading data from console:

import java.io.*;
class MyInput
{
public static void main(String[] args)
{
String text;
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
text = br.readLine(); //Reading String
System.out.println(text);
}
}

Writing Characters To The Console

/*
Write character sequence output to the console using PrintWriter
*/
import java.io.*; // Import all file classes from java.io package

class TestPrintWriter {
public static void main(String[] args) {
char someData[] = new char[]{'J','a','v','a'};
char someData2[] = new char[]{'J','á','v','á'};
double d = 128.128;

PrintWriter pw = new PrintWriter(System.out, true); // Create a PrintWriter stream to console

System.out.println("PrintWriter pw has been opened.");
pw.println("Writing a string with PrintWriter.");
pw.println("Writing a char array with PrintWriter: " + someData);
pw.println("Writing an internationalized char array with PrintWriter: " + someData2);

St. Joseph’s College of Engineering Page 19 of 20

DS 1302 / CS 1303 Object Oriented Programming Common to CSE & ADS
pw.println("Writing a double primitive with PrintWriter: " + d);
}
}

Using Scanner class

class sample {
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
System.out.print("Enter your nationality: ");
String nationality = scanner.nextLine();
System.out.print("Enter your age: ");
int age = scanner.nextInt();
}

St. Joseph’s College of Engineering Page 20 of 20