Chapter 2

1 By Adugna H; 04/20/2024
String class
• in Java a string is a sequence of characters.
• But, unlike many other languages that implement strings as character arrays,
Java implements strings as objects of type String.
• when you create a String object, you are creating a string that cannot be
changed.
• That is a, once a String object has been created, you cannot change the
characters that comprise that string.
• You can still perform all types of string operations.
• The difference is that each time you need an altered version of an existing
string, a new String object is created that contains the modifications.
• The original string is left unchanged.
Some important methods of string class
string length

• the length of a string is the number of character that it contains

int length()

ex;

char chars[]={‘a’,’b’,’c’};

String s=new String(chars);

System.out.println(s.length());
Character extraction

charAt():

to extract a single character from a string by using

index.

char charAt(int where)

Ex:

char ch;

ch=“abc”.charAt(1);
String comparison
• To compare the strings or substrings within strings.
equals() and equalsIgnoreCase()
Syntax:
Boolean equals(Object str)
-str is the String object being compared with the
invoking String object
class Teststringcomparison2{
public static void main(String args[]){
String s1="Sachin";
String s2="SACHIN";
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s2));/
/true
}
}
 2) By Using == operator
The == operator compares references not values.

class Teststringcomparison3{
public static void main(String args[]){
String s1="Sachin";
String s2="Sachin";
System.out.println(s1==s2);//
true (because both refer to same instance)
}
}

6 By Adugna H; 04/20/2024
 3) String compare by compareTo() method
The above code, demonstrates the use of == operator used for comparing
two String objects.

3) By Using compareTo() method

The String class compareTo() method compares values lexicographically
and returns an integer value that describes if first string is less than, equal to
or greater than second string.
Suppose s1 and s2 are two String objects. If:
•s1 == s2 : The method returns 0.
•s1 > s2 : The method returns a positive value.
•s1 < s2 : The method returns a negative value.

7 By Adugna H; 04/20/2024
 class Teststringcomparison4{
public static void main(String args[]){
String s1="Sachin";
String s2="Sachin";
String s3="Ratan";
System.out.println(s1.compareTo(s2));//0
System.out.println(s1.compareTo(s3));//1(because s1>s3)
System.out.println(s3.compareTo(s1));//-1(because s3 < s1 )
}
}

8 By Adugna H; 04/20/2024
Searching Strings

indexOf( ) Searches for the first occurrence of a character or substring.

lastIndexOf( ) Searches for the last occurrence of a character or substring.

class IndexOfDemo {

public static void main(String args[ ]) {

String s = "Now is the time for all good men " +

"to come to the aid of their country.";

System.out.println(s);

System.out.println("indexOf(t) = " + s.indexOf('t'));

System.out.println("lastIndexOf(t) = " + s.lastIndexOf('t'));
System.out.println("indexOf(the) = " + s.indexOf("the"));
System.out.println("lastIndexOf(the) = " + s.lastIndexOf("the"));
System.out.println("indexOf(t, 10) = " + s.indexOf('t', 10));
System.out.println("lastIndexOf(t, 60) = " + s.lastIndexOf('t', 60));
System.out.println("indexOf(the, 10) = " + s.indexOf("the", 10));
System.out.println("lastIndexOf(the, 60) = " + s.lastIndexOf("the", 60));
}}
String replace(char original, char replacement)

• The replace( ) method replaces all occurrences of one

character in the invoking string

with another character.

class ReplaceDemo {

public static void main(String[] args) {

String str1 = "RISK";

String str2 = str1.replace('R','D’);

System.out.println("First String : "+str1);

System.out.println("Second String : "+str2);

String str3 = str1.replaceAll("RI","A");

System.out.println("Third String : "+str3);

}
}
 Changing the Case of Characters Within a String

String toLowerCase( ):to change into lower case

String toUpperCase( ): to change into upper case

class LowerUpper {

public static void main(String args[]) {

String str1 = "java";

String str2 = "JAVA";

System.out.println("Upper Case Of : "+str1+" is : "+str1.toUpperCase());

System.out.println("Lower Case Of : "+str2+" is : "+str2.toLowerCase());

}}
 Exception
Handling

14 By Adugna H; 04/20/2024
 Exception
15

 An exception is a problem that arises during the execution of

a program. An exception can occur for many different reasons,
including the following:
 A user has entered invalid data.
 A file that needs to be opened cannot be found.
 A network connection has been lost in the middle of
communications, or the JVM has run out of memory.
 Some of these exceptions are caused by user error, others by
programmer error, and others by physical resources that have
failed in some manner.

By Adugna H; 04/20/2024
16
Categories of Exception
1. Checked exceptions: A checked exception is an exception that is typically a
user error or a problem that cannot be foreseen by the programmer. For
example, if a file is to be opened, but the file cannot be found, an exception
occurs. These exceptions cannot simply be ignored at the time of compilation.
2. Runtime exceptions: A runtime exception is an exception that occurs that
probably could have been avoided by the programmer. As opposed to checked
exceptions, runtime exceptions are ignored at the time of compilation.
3. Errors: These are not exceptions at all, but problems that arise beyond the
control of the user or the programmer. Errors are typically ignored in your
code because you can rarely do anything about an error. For example, if a
stack overflow occurs, an error will arise. They are also ignored at the time of
compilation.

By Adugna H; 04/20/2024
 Exception Hierarchy
17

 All exception classes are subtypes of the java.lang.Exception class. The

exception class is a subclass of the Throwable class. Other than the exception
class there is another subclass called Error which is derived from the
Throwable class.
 The Exception class has two main subclasses :
₪ IOException class
₪ RuntimeException Class.

By Adugna H; 04/20/2024
 Catching Exceptions
18
 A method catches an exception using a combination of
the try and catch keywords. A try/catch block is placed around the code
that might generate an exception. Code within a try/catch block is referred
to as protected code, and the syntax for using try/catch looks like the
following:
try {
//Protected code
}catch(ExceptionName e1)
{
//Catch block
}
 A catch statement involves declaring the type of exception you are trying
to catch. If an exception occurs in protected code, the catch block (or
blocks) that follows the try is checked. By Adugna H;
04/20/2024
 Example: // File Name : ExcepTest.java
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");
}
19 By Adugna H; 04/20/2024
}
20
Multiple Catch Blocks
Syntax: try
{
//Protected code
}
catch(ExceptionType1 e1)
{
//Catch block
}
catch(ExceptionType2 e2)
{
//Catch block
}
catch(ExceptionType3 e3)
{
//Catch block
}
By Adugna H; 04/20/2024
21
Throws/Throw
•If a method does not handle a checked exception, the method
must declare it using the throws keyword.

•The throws keyword appears at the end of a method's signature.

•You can throw an exception, either a newly instantiated one or

an exception that you just caught, by using the throw keyword.

By Adugna H; 04/20/2024
 Remote Exception
22

import java.io.*;
public class className
{
public void deposit(double amount) throws RemoteException
{
// Method implementation
throw new RemoteException();
}
//Remainder of class definition
}

By Adugna H; 04/20/2024
 Example:
Function throws a RemoteException and an
InsufficientFundsException

import java.io.*;
public class className
{
public void withdraw(double amount) throws RemoteException,
InsufficientFundsException
{
// Method implementation
}
//Remainder of class definition
}

23 By Adugna H; 04/20/2024
24
Finally Keyword
 The finally keyword is used to create a block of code that
follows a try block.

A finally block of code always executes, whether or not an

exception has occurred.

 Using a finally block allows you to run any cleanup-type

statements that you want to execute, no matter what
happens in the protected code.

By Adugna H; 04/20/2024
 Syntax:
try
{
//Protected code
}
catch(ExceptionType1 e1)
{
//Catch block
}
catch(ExceptionType2 e2)
{
//Catch block
}
catch(ExceptionType3 e3)
{
//Catch block
}
finally
{
//The finally block always executes.
25 } By Adugna H; 04/20/2024
 Example:
public class ExcepTest
{
public static void main(String args[])
{
int a[] = new int[2];
try
{
System.out.println("Access element three :" + a[3]);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Exception thrown :" + e);
}
finally
{
a[0] = 6;
System.out.println("First element value: " +a[0]);
System.out.println("The finally statement is executed");
}
}
26 By Adugna H; 04/20/2024
}
 Declaring Your Own Exception
27

You can create your own exceptions in Java. Keep the following
points in mind when writing your own exception classes:

€ All exceptions must be a child of Throwable.

€ If you want to write a checked exception that is
automatically enforced by the Handle or Declare Rule, you
need to extend the Exception class.
€ If you want to write a runtime exception, you need to
extend the RuntimeException class.

By Adugna H; 04/20/2024
 Syntax:
class MyException extends Exception{ }

Example Module:
// File Name InsufficientFundsException.java
import java.io.*;
public class InsufficientFundsException extends Exception
{
private double amount;
public InsufficientFundsException(double amount)
{
this.amount = amount;
}
public double getAmount()
{
return amount;
}
28 } By Adugna H; 04/20/2024
 Example Program:
// File Name CheckingAccount.java
import java.io.*;

public class CheckingAccount

{
private double balance;
private int number;
public CheckingAccount(int number)
{
this.number = number;
}
public void deposit(double amount)
{
balance += amount;
}
29 By Adugna H; 04/20/2024
 public void withdraw(double amount) throws InsufficientFundsException
{
if(amount <= balance)
{
balance -= amount;
}
else
{
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}
public double getBalance()
{
return balance;
}
public int getNumber()
{
return number;
}
}

30 By Adugna H; 04/20/2024
 // File Name BankDemo.java deposit() and withdraw()
public class BankDemo methods
{
public static void main(String [] args)
{
CheckingAccount c = new CheckingAccount(101);
System.out.println("Depositing $500...");
c.deposit(500.00);
try
{
System.out.println("\nWithdrawing $100...");
c.withdraw(100.00);
System.out.println("\nWithdrawing $600...");
c.withdraw(600.00);
}
catch(InsufficientFundsException e)
{
System.out.println("Sorry, but you are short $" +
e.getAmount());
e.printStackTrace();
}
}
31 } By Adugna H; 04/20/2024
 Reading Assignment
32

File and java stream

By Adugna H; 04/20/2024
33

The end

By Adugna H; 04/20/2024