Unit 5 notes.pdf

191AIC302T-Object Oriented Programming with SCALA
Unit-V
Department of AI & DSPage 1
Exception handling and Multithreading
Exception handling: Try-Catch Blocks - Finally Block - Throw Keyword - Throws
Keyword - Custom Exception – Multithreading: Thread - Thread Life Cycle – Thread
Methods – Collections - File Handling
Exception Handling
 An exception is an unwanted or unexpected event, which occurs during the execution of a
program i.e at run time. These events change the flow control of the program in
execution. These are situations that are not too dangerous and can be handled by the
program.
Exception Hierarchy
All exception and errors types are sub classes of class Throwable, which is base class of
hierarchy. One branch is headed by Exception. This class is used for exceptional conditions that
user programs should catch. NullPointerException is an example of such an exception. Another
branch, Error are used by the Java run-time system(JVM) to indicate errors having to do with the
run-time environment itself(JRE). StackOverflowError is an example of such an error.
 Exception handling is a mechanism which is used to handle abnormal conditions. You
can also avoid termination of your program unexpectedly.

Unit-V
 Scala makes "checked vs unchecked" very simple. It doesn't have checked exceptions.
All exceptions are unchecked in Scala, even SQLException and IOException.
Scala Program Example without Exception Handling
class ExceptionExample{
def divide(a:Int, b:Int) = {
a/b // Exception occurred here
println("Rest of the code is executing...")
}
}
object MainObject{
def main(args:Array[String]){
var e = new ExceptionExample()
e.divide(100,0)
}
}
Try Catch
Scala provides try and catch block to handle exception. The try block is used to enclose suspect
code. The catch block is used to handle exception occurred in try block. You can have any
number of try catch block in your program according to need.
Scala Try Catch Example
In the following program, we have enclosed our suspect code inside try block. After try block we
have used a catch handler to catch exception. If any exception occurs, catch handler will handle
it and program will not terminate abnormally.
try{

Unit-V
a/b
}catch{
case e: ArithmeticException => println(e)
}
}
}
object MainObject{
e.divide(100,0)
}
}
Output:
java.lang.ArithmeticException: / by zero
Rest of the code is executing...
Scala Try Catch Example 2
In this example, we have two cases in our catch handler. First case will handle only arithmetic
type exception. Second case has Throwable class which is a super class in exception hierarchy.
The second case is able to handle any type of exception in your program. Sometimes when you
don't know about the type of exception, you can use super class.
try{
a/b
var arr = Array(1,2)

Unit-V
arr(10)
}catch{
case ex: Throwable =>println("found a unknown exception"+ ex)
}
}
}
object MainObject{
e.divide(100,10)
}
}
Finally
The finally block is used to release resources during exception. Resources may be file, network
connection, database connection etc. the finally block executes guaranteed. The following
program illustrate the use of finally block.
Scala Finally Block Example
try{
a/b
var arr = Array(1,2)
arr(10)

Unit-V
}catch{
case ex: Exception =>println(ex)
case th: Throwable=>println("found a unknown exception"+th)
}
finally{
println("Finaly block always executes")
}
}
}
object MainObject{
e.divide(100,10)
}
}
Throw keyword
You can throw exception explicitly in you code. Scala provides throw keyword to throw
exception. The throw keyword mainly used to throw custom exception. An example is given
below of using scala throw exception keyword.
Scala Throw Example
class ExceptionExample2{
def validate(age:Int)={
if(age<18)

Unit-V
throw new ArithmeticException("You are not eligible")
else println("You are eligible")
}
}
object MainObject{
var e = new ExceptionExample2()
e.validate(10)
}
}
Throws Keyword
Scala provides throws keyword to declare exception. You can declare exception with method
definition. It provides information to the caller function that this method may throw this
exception. It helps to caller function to handle and enclose that code in try-catch block to avoid
abnormal termination of program. In scala, you can either use throws keyword or throws
annotation to declare exception.
Scala Throws Example
class ExceptionExample4{
@throws(classOf[NumberFormatException])
def validate()={
"abc".toInt
}
}
object MainObject{
var e = new ExceptionExample4()

Unit-V
try{
e.validate()
}catch{
case ex : NumberFormatException => println("Exception handeled here")
}
println("Rest of the code executing...")
}
}
Custom Exception
In scala, you can create your own exception. It is also known as custom exceptions. You must
extend Exception class while declaring custom exception class. You can create your own
exception message in custom class. Let's see an example.
Scala Custom Exception Example
class InvalidAgeException(s:String) extends Exception(s){}
@throws(classOf[InvalidAgeException])
def validate(age:Int){
if(age<18){
throw new InvalidAgeException("Not eligible")
}else{
println("You are eligible")
}
}
}
object MainObject{

Unit-V
try{
e.validate(5)
}catch{
case e : Exception => println("Exception Occured : "+e)
}
}
}
Multithreading
 Multithreading is a process of executing multiple threads simultaneously. It allows you to
perform multiple operations independently.
 You can achieved multitasking by using Multithreading. Threads are lightweight sub-
processes which occupy less memory. Multithreading are used to develop concurrent
applications in Scala.
 Scala does not provide any separate library for creating thread. If you are familiar with
multithreading concept of Java, you will come to know that it is similar except the syntax
of Scala language itself.
 You can create thread either by extending Thread class or Runnable interface. Both
provide a run method to provide specific implementation.
Scala Thread Life Cycle
Thread life cycle is a span of time in which thread starts and terminates. It has various phases
like new, runnable, terminate, block etc. Thread class provides various methods to monitor
thread's states.
The Scala thread states are as follows:
1. New
2. Runnable
3. Running
4. Non-Runnable (Blocked)
5. Terminated

Unit-V
1) New
This is the first state of thread. It is just before starting of new thread.
2) Runnable
This is the state when thread has been started 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 due to waiting
for input or resources.
5) Terminated
A thread is in terminated or dead state when its run() method exits.

Unit-V
Thread
There are two ways to create a thread:
1. By extending Thread class
2. By implementing Runnable interface
Scala Thread Example by Extending Thread Class
The following example extends Thread class and overrides run method. The start() method is
used to start thread.
class ThreadExample extends Thread{
override def run(){
println("Thread is running...");
}
}
object MainObject{
var t = new ThreadExample()
t.start()
}
}
Output:
Thread is running...
Scala Thread Example by Extending Runnable Interface
The following example implements Runnable interface and overrides run method. The start()
method is used to start thread.
class ThreadExample extends Runnable{

Unit-V
override def run(){
println("Thread is running...")
}
}
object MainObject{
var e = new ThreadExample()
var t = new Thread(e)
t.start()
}
}
Thread Methods
Thread class provides various methods to deals with thread's states. You can use these methods
to control the flow of thread.
The following table contains commonly used methods of Thread class.

Unit-V
Thread sleep() Method
The sleep() method is used to sleep thread for the specified time. It takes time in milliseconds as
an argument.
override def run(){
for(i<- 0 to 5){
println(i)
Thread.sleep(500)
}
}

Unit-V
}
object MainObject{
var t1 = new ThreadExample()
t1.start()
t2.start()
}
}
Thread join() Method Example
The join() method waits for a thread to die. In other words, The join() method is used to hold the
execution of currently running thread until the specified thread finished it's execution.
override def run(){
for(i<- 0 to 5){
println(i)
Thread.sleep(500)
}
}
}
object MainObject{

Unit-V
t1.start()
t1.join()
t2.start()
t3.start()
}
}
setName() Method Example
In the following example, we are setting and getting names of threads.
class ThreadExample() extends Thread{
override def run(){
for(i<- 0 to 5){
println(this.getName()+" - "+i)
Thread.sleep(500)
}
}
}
object MainObject{
t1.setName("First Thread")
t2.setName("Second Thread")
t1.start()
t2.start()

Unit-V
}
}
Thread Priority Example
You can set thread priority by using it's predefined method. The following example sets priority
for the thread.
override def run(){
for(i<- 0 to 5){
println(this.getName())
println(this.getPriority())
Thread.sleep(500)
}
}
}
object MainObject{
t1.setName("First Thread")
t2.setName("Second Thread")
t1.setPriority(Thread.MIN_PRIORITY)
t2.setPriority(Thread.MAX_PRIORITY)
t1.start()
t2.start()
}

Unit-V
}
Thread Multitasking Example
The following example is running multiple tasks by using multiple threads. This example
explains that how can we implement multitasking in Scala.
override def run(){
for(i<- 0 to 5){
println(i)
Thread.sleep(500)
}
}
def task(){
for(i<- 0 to 5){
println(i)
Thread.sleep(200)
}
}
}
object MainObject{
t1.start()
t1.task()
}
}

Unit-V
Collections
Collections are the container of things that contains a random number of elements. All collection
classes are found in the package scala.collection. Collections are of two types –
1. Mutable Collections
2. Immutable Collections
Mutable Collection – This type of collection is changed after it is created. All Mutable
collection classes are found in the package scala.collection.mutable.
Immutable Collection – This type of collection will never change after it is created. All
Immutable collection classes are found in the package scala.collection.immutable.
Most Common Collection types are –
 List
 Map
 Set
 Tuple
 Iterators
List
List is a collection of similar types of elements which are immutable. It represents the Linked
list. If the list contains t types of elements then it can be represented as –
List[t]
The empty list is specified by Nil which is an object that represents an empty list. The method::
pronounced cons transforms an object and a list into a new list whose head is the object and
whose tail is the first list.
val numbers: List[Int] = List(10, 20, 30 ,40) //List of Integers
val empty: List[Int] = List() // Empty List
val twodim: List[List[Int]] =
List (
List (0, 1, 0),
List (1, 1, 0)
)

Unit-V
List Constructors –
All lists are built from two more fundamental constructors that are Nil and::.Nil represents an
empty list. The infix operator:: expresses list extension. That is, x:: xs represents a list whose
first element is x, which is followed by list xs. You can also define the list as follows:
val numbers = 10 :: (20 :: (30 :: (40 :: Nil)))
val empty = Nil
val twodim = (0 :: (1 :: (0 :: Nil))) ::
(1 :: (1 :: (0 :: Nil))) :: Nil
For simplicity you can define the above list as follows:-
val numbers = 10 :: 20 :: 30 :: 40 :: Nil
e.g.
object Intellipaat {
def main(args: Array[String]) {
val numbers = 10 :: (20 :: (30 :: (40 :: Nil)))
val data = Nil
println( "Head of Number is : " + numbers.head )
println( "Tail of Number is : " + numebrs.tail )
println( "Check number is empty or not : " + numbers.isEmpty )
println( "Check data is empty or not : " + data.isEmpty )
}

Unit-V
}
 List.concat() – It is used to perform concatenation of two lists.
 List.fill() – It creates a list that contains the same element.
 List.tabulate() – It converts the list in tabular form.
 List.reverse – It is used to reverse the list elements.
Map (Hash Table)
It is a collection of key/value pairs where keys are unique and value is retrieved according to the
key. Scala Online Training provides mutable and immutable versions of Map. If you want to use
an immutable map then use Map and if you want to use a mutable map the use mutable. Map.
e.g.
var I:Map[String ,Int] = Map() // Creates empty hash table whose values are integers and keys
are string type
val data = Map(
‘a’ ->10,
‘b’ -> 20,
‘c’->30,
‘d’ ->40
)

Unit-V
e.g.
val numbers = Map(
‘a’ ->10, ‘b’ -> 20, ‘c’->30, ‘d’ ->40
)
val data: Map[char, Int] = Map()
println( "Keys in Numbers are : " + numbers.keys )
println( "Values in numbers are : " + numbers.values )
}
}
 Map.++() – It is used to concatenate two or more maps.
 Map.contains – It checks that if a given key exists in the map or not.
 Foreach loop – It is used to print the keys and values of the map.
Set
It is a collection of elements that are of the same type but do not contain the same elements. By
default, scala uses an immutable set. Scala provides mutable and immutable versions of Set. If

Unit-V
you want to use an immutable set then use Set and if you want to use mutable set the use
mutable. Set.
var i : Set[Int] = Set() // Empty set of integer type
var i : Set[Int] = Set(10, 20, 30, 40) // Set of integer type
Basic Operations on Set:
All operations on sets can be expressed in terms of the following three methods:
e.g.
val numbers = Set(10, 20, 30, 40)
val data: Set[Int] = Set()
println( "Head of Number is : " + numbers.head )
println( "Tail of numbers is : " + numbers.tail )

Unit-V
}
}
 Set.++() – It is used to concatenate the two or more sets.
 Set.min – It is used to find the minimum value from the elements of the set.
 Set.max() – It is used to find the maximum value from the elements of the set.
 Set.intersect – It is used to find the common values between two sets.
 Set.& – It is also used to find the common values between two sets.
Tuples
It is a collection of heterogeneous types of objects that is different types of objects which
combine a fixed number of items together.
A tuple that contains an Int and a String:
val i = (1, "intellipaat")
To access tuple elements ‘._’ is used.
e.g.
val i = (10, 20, 30, 40)
val total = i._1 + i._2 + i._3 + i._4
println( "Total of Elements is : " + total)
}
}
 Tuple.productIterator() – It is used to iterate over all the elements of a Tuple.
 Tuple.toString() – It is used to concatenate all the elements of the tuple into a string.
 Tuple.swap – It is used to swap the elements of a Tuple.
Iterator

Unit-V
It is used to access the elements of the collection one by one. Two important operations of an
iterator are –
 next
 hasNext
next – It is used to return the next element of the iterator and move ahead of the state of the
iterator.
hasNext – It is used to find out whether there are more elements to return.
e.g.
val i = Iterator("hello", "intellipaat", "a", "ecommerce", “site”)
while (i.hasNext){
println(i.next())
}
}
}
 iterartor.min – It is used to return the minimum value elements form iterator.
 iterator.max – It is used to return the maximum value elements form iterator.
 iterator.size – It is used to return the number of elements in the iterator.
 iterator.length – It is also used to return the number of elements in the iterator.
File Handling
File Handling is a way to store the fetched information in a file. Scala provides packages from
which we can create, open, read and write the files. For writing to a file in scala we borrow
java.io._ from Java because we don’t have a class to write into a file, in the Scala standard
library. We could also import java.io.File and java.io.PrintWriter.
Creating a new file :
java.io.File defines classes and interfaces for the JVM access files, file systems and attributes.

Unit-V
File(String pathname) converts theparameter string to abstract path name, creating a new file
instance.
Writing to the file
java.io.PrintWriter includes all the printing methods included in PrintStream.
Below is the implementation for creating a new file and writing into it.
// File handling program
import java.io.File
import java.io.PrintWriter
// Creating object
object Geeks
{
// Main method
def main(args:Array[String])
{
// Creating a file
val file_Object = new File("abc.txt" )
// Passing reference of file to the printwriter
val print_Writer = new PrintWriter(file_Object)
// Writing to the file
print_Writer.write("Hello, This is Geeks For Geeks")
// Closing printwriter
print_Writer.close()
}
}

Unit-V
A text file abc.txt is created and contains the string “Hello, This is Geeks For Geeks”
Scala does not provide class to write a file but it provide a class to read the files. This is the class
Source. We use its companion object to read files. To read the contents of this file, we call the
fromFile() method of class Source for reading the contents of the file which includes filename as
argument.
Reading a File
scala.io.Source includes methods for iterable representation of the source file.
Source.fromFile creates a source from the input file.
file.next return the next element in the iteration and moves the iterator one step ahead.
file.hasnext checks if there is next element available to iterate.
getLines– Iterate through file line by line
Below is the implementation for Reading each character from a file.
// Scala File handling program
import scala.io.Source
// Creating object
object GeeksScala
{
// Main method
def main(args : Array[String])
{
// file name
val fname = "abc.txt"
// creates iterable representation
// of the source file
val fSource = Source.fromFile(fname)
while (fSource.hasNext)

Unit-V
{
println(fSource.next)
}
// closing file
fSource.close()
}
}
Output:
We can use getLines() method to read individual lines instead of the whole file at once.
Below is the implementation for Reading each line from a file.
// Scala file handling program to Read each
// line from a single file
// Creating object
object gfgScala
{
// Main method
def main(args:Array[String])
{
val fname = "abc.txt"
val fSource = Source.fromFile(fname)
for(line<-fSource.getLines)
{
println(line)
}

Unit-V
fSource.close()
}
}
Creating a file in Scala and writing content to it
As Scala, uses Java library the libraries of java methods are used.
In this program to will create a new file called by file myfile.txt and then write one sentence in
the file.
Program to create a file in Scala
import java.io._
object WriteFileExample {
// creating file object
val file = new File("myfile.txt" )
//creating object of the PrintWrite
//by passing the reference to the file
val pw = new PrintWriter(file)
//writing text to the file
pw.write("Welcome @ IncludeHelpn")
pw.write("writing text to the filen")
//closing the PrintWriter
pw.close()
println("PrintWriter saved and closed...")
}
}

Unit-V
Output
PrintWriter saved and closed...
Reading Content line by line in Scala
You can alternatively read the contents of a file in Scala line by line,
object MainObject{
//file name
val filename = "myfile.txt"
//file reading - creating object name by passing
//filename i.e. file object
val filereader = Source.fromFile(filename)
//printing characters
for(line<-fileSource.getLines){
println(line)
}
//closing
filereader.close()
}
}

Unit 5 notes.pdf

Recommended

Recommended

More Related Content

Similar to Unit 5 notes.pdf

Similar to Unit 5 notes.pdf (20)

More from Revathiparamanathan

More from Revathiparamanathan (20)

Recently uploaded

Recently uploaded (20)

Unit 5 notes.pdf