Core java

10 January 2018 www.snipe.co.in 1
SNIPE TEAM
01/12/2017

CONTENTS:
 HISTORY
 WHY JAVA
 GETTING STARTED
 FUNDAMENTALS
 ARRAY
 STRING
 COLLECTIONS
 GENERICS
 MULTI-THREADING
 EXCEPTION HANDLING
 REGULAR EXPRESSIONS
 ANNOTATION
 ENUM
 FAQ’s
1/10/2018
3
CONTENTS

History:
 Java is a General Purpose, Object Oriented Programming
Language developed by James Gosling at Sun
Microsystems in 1991 and released in 1995.
 Originally designed for small, embedded systems in
electronic appliances like set-top boxes.
 There are many java versions that has been released,
current stable release of java is Java SE 9 released On
21 September 2017.
1/10/2018
4
HISTORY

Why Java:
o Simple
o Platform Independent
o Object Oriented
o Robust and Secure
o Statically and Strongly typed
o Multithreaded
o Architectural-Neutral
o Interpreted and High Performance
o Distributed
1/10/2018 5

Environment Setup:
Java is one of the most popular programming languages used to create Web
applications and platforms.
It was designed for flexibility, allowing developers to write code that would run on
any machine, regardless of architecture or platform.
Popular Java Editors:
 Notepad − On Windows machine, you can use any simple text editor like
Notepad or TextPad.
 Netbeans − It is a Java IDE that is open-source and free. It can be downloaded
from https://netbeans.org/index.html.
 Eclipse − It is also a Java IDE developed by the Eclipse open-source community
and can be downloaded from https://www.eclipse.org/.
1/10/2018 6
GETTING STARTED

JDK, JRE and JVM:
Java Environment includes a large number of development tools and
hundreds of classes and methods. and the classes and methods are part of the
Java Standard Library (JSL), also known as the Application Programming
Interface (API).
o JVM: The JVM provides runtime environment in which java bytecode can
be Loaded, Verified and executed.
o JRE: It is the implementation of JVM. It physically exists. It contains
set of libraries + other files that JVM uses at runtime.
7
ENVIRONMENT SETUP

JDK, JRE and JVM (Continue… ):
o JDK: Java Development Kit comes with a collection of tools that are used for
developing and JRE for running Java Programs. JDK officially named "Java
Platform Standard Edition (Java SE)", includes a complete JRE plus tools for
developing, debugging, and monitoring Java applications.
8
ENVIRONMENT SETUP

Sample Java Program:
• class keyword is used to declare a class ‘SNIPE’ in java.
• public keyword is an access modifier which makes visible to all.
• static keyword is used to declare method is known as static method.
The core advantage is that there is no need to create object to invoke
the static method. So it saves memory.
• void is the return type of the method, it doesn't return any value.
• main represents startup of the program.
• String[] args is used for command line argument.
• System.out.println() is used print statement ‘SNIPE Tech Pvt. Ltd.’.
1/10/2018 9
FUNDAMENTALS
class Snipe{
public static void main(string[] args)
{
System.out.println("SNIPE Tech Pvt. Ltd.");
} } // O/P - SNIPE Tech Pvt. Ltd.

1/10/2018
FUNDAMENTALS
Keywords:
It is a reserved word in programming language which is predefined and cannot
be used as name for class, method, function and identifier.
abstract const final interface strictfp
Assert continue finally long super
boolean default float native for
break do goto package synchronized
case double if private this
catch else implements public protected
char enum import instanceof throws
class extends int short try
transient byte static while new
return void volatile switch throw

Variables:
A variable denotes a storage location used to store a data value.
It is defined by the combination of an identifier , a type, and an optional initializer.
Syntax: Example:
Types of Variable:
 Local variable - A variable which is declared inside the method.
 Instance variable - A variable which is declared inside the class but outside the
method and it is not declared as static.
 Static variable - A variable that is declared as static. It cannot be local.
1/10/2018 11
FUNDAMENTALS
int a = 80;type variable-name=value;

Example for different type of variables:
1/10/2018 12
FUNDAMENTALS
class A{
int data=50; //instance variable
Static int m=100; //static variable
void method(){
int n=90;//local variable
}
} //end of class

Data Types:
It is a keyword, represents a kind of data used to allocate sufficient memory
space for the data.
Here, speed is a variable, and the data type of the variable is int.
The int data type determines that the speed variable can only contain integers.
Data types are classified into two types –
o Primitive Data Types
o Non-Primitive Data Types
1/10/2018 13
FUNDAMENTALS
int speed;

1/10/2018
FUNDAMENTALS
Description of Data Types:
Data Type Keyword Kinds of value Bytes of
Memory
Range of values
Byte byte Integer 1 -128 to 127
Character char 1 character - unicode 2 Not applicable
Short
integer
short integer 2 -32,768 to 32,767
Integer int integer 4 -2,147,483,648 to
2,147,483,647
Long
integer
long integer 8 -9,223,372,036,854,775,808
to 9,223,372,036,854,775,807
Float float Decimal values to 7
decimal digit precision
4 3.4e-38 to 3.4e38
Double double Decimal values to 15
decimal digit precision
8 1.7e-308 to 1.73e308
Boolean boolean Boolean values
True/false
1 Not applicable

Classifications of Data Types:
1/10/2018 15
FUNDAMENTALS
DATA TYPES
PRIMITIVE
NUMERIC
NON-
PRIMITIVE
NON-
NUMERIC
CLASS
ARRAY
STRING
INTEGER
FLOATING
POINT
CHARACTER
BOOLEAN
BYTE
SHORT
INT
LONG
FLOAT
DOUBLE

Operators:
Operator in java is a symbol that is used to perform operations.
Types of Operators in Java:
1/10/2018
16
Operator Type Precedence
Arithmetic
Operator
+, -, *, /, %, ++, += , -=, *=, /= ,%= , --
Bitwise Operator ~, &, |, ^, >>, >>>, <<, &=, |=, ^=, >>=, >>>=, <<=
Relational
Operator
==, !=, >, <, >=, <=
Logical Operators ||, &&, !
Assignment
Operator
=
Ternary Operator ? :
FUNDAMENTALS

Example for operators:
1/10/2018 17
public class ArithmeticDemo {
public static void main(String[] args) {
int x = 10;
int y = 20;
int result = x + y;
System.out.println("x + y = " + result); // O/P- x + y = 30
result = x - y;
System.out.println("x - y = " + result); // O/P- x - y = -10
result = x * y;
System.out.println("x * y = " + result); // O/P- x * y = 200
result = y / x;
System.out.println("y / x = " + result); // O/P- y / x = 2
result = x % 3;
System.out.println("x % 3 = " + result); // O/P- x + 3 = 1
}
}
FUNDAMENTALS

Control Statements:
o if statement :
• ‘if’ is used to perform conditional checks.
• It checks boolean condition: true or false.
• There are various types:
1. ‘if’ statement
2. ‘if-else’ statement
3. ‘if-else-if’ ladder
4. ‘nested if’ statement
1/10/2018 18
Syntax:
if(condition) {
statement 1;
} else {
statement 2;
}
statement X;
FUNDAMENTALS

Control Statements (Continue..) :
o switch/case : Switch statement is used
to execute a particular set of statements
among multiple conditions.
o for : for loop is used to execute a set
of statements multiple times.
• There are three types of for loop in java.
1. Simple for loop
2. for-each or enhanced for loop
3. labeled for loop
1/10/2018 19
Syntax:
for(initialization; condition; increment/decrement)
{
Statement 1:
}
Syntax:
switch(expression){
case value1:
//code to be executed;
break; //optional
case value2:
//code to be executed;
break; //optional
......
default:
code to be executed if all cases are not matched;}
FUNDAMENTALS

o while : It is an entry controlled loop.
In while, 1st condition will be verified.
If the condition is true, loop will be
repeated. If the condition is false then
control come out of the loop.
o do-while : It is a exit controlled loop.
In do-while, 1st all the statements
inside the block will be executed and
then condition will be verified.
1/10/2018 20
FUNDAMENTALS
class WhileDemo {
int i = 1;
while (i <= 3) {
System.out.println("Num is: " + i);
i++; } }
} /* O/P – 1
2
3 */
Example:
class DoWhileDemo {
int i = 11;
do {
System.out.println("Num is: " + i);
i++;
} while (i <= 10);
}
} // O/P – 11

o break – It helps to transfer control to
another part of the program.
o continue – It is used when you want to
continue running the loop with the next
iteration and want to skip the rest of
the statements of the body for the
current iteration.
o return – It terminates the execution in
a method and return the control to the
caller method.
1/10/2018 21
FUNDAMENTALS
public class BreakDemo {
for(int i=1;i<=10;i++) {
if(i==4) {
break; }
System.out.println(i);
} } } /* O/P – 1
2
3 */
public class BreakDemo {
for(int i=1;i<=4;i++) {
if(i==2) {
continue; }
System.out.println(i);
} } } /* O/P – 1
3
4 */
Example:

Identifiers :
Identifiers are used for class names, method names, variable names.
An identifier must start with uppercase and lowercase letters, numbers, or the
underscore and dollar-sign characters.
Valid Identifiers:
Invalid Identifiers:
Literals:
A constant value in java is created by using a literal representation of it.
1/10/2018 22
AvgTemp count a4 $test this_is_ok
2count high-temp Not/ok
100 98.6 ‘X’ “This is test”
FUNDAMENTALS

Object-Oriented Programming:
It is a methodology or paradigm to design a program using classes and objects.
It simplifies the software development and maintenance by providing various
concepts:
• Object
• Class
• Inheritance
• Polymorphism
• Abstraction
• Encapsulation
1/10/2018 23
OOPS CONCEPTS

Object:
An entity that has state and behavior is known as an object.
It can be physical or logical. Example: chair, bike, marker, pen, table, car etc.
o An object has three characteristics:
• State: It represents data (value) of an object.
• Behavior: It represents the behavior (functionality) of an object such as
deposit, withdraw etc.
• Identity : It gives a unique name to an object and enables one object to
interact with other objects.
1/10/2018 24
OOPS CONCEPTS

Class:
A class is a group of objects which have common properties.
It is a template or blueprint from which objects are created.
A class contains:
• fields
• methods
• constructors
• blocks
• nested class and interface
1/10/2018 25
OOPS CONCEPTS
Syntax:
class <class_name>
{
field;
method;
}

Constructor:
It is a special method having same name of class having no return type, used
to initialize the instance members and the object.
Types of constructor:
 Default constructor -
A constructor that have no parameter is known as default constructor.
 Parameterized constructor - A constructor that have parameters is known as
parameterized constructor.
1/10/2018 26
OOPS CONCEPTS
syntax: <class_name> () {}
syntax: <class_name>(parameters) {}

Inheritance:
It is a mechanism in which one object acquires all the properties and behaviors
of parent object.
Inheritance represents the IS-A relationship, also known as parent-child
relationship.
Why inheritance in java
o For Method Overriding (so runtime polymorphism can be achieved).
o For Code Reusability.
1/10/2018 27
OOPS CONCEPTS
class Subclass-name extends Superclass-name
{
//methods and fields
}
Syntax:
Class Superclass-name
{
//methods and fields
}

Types of Inheritance:
o Single Inheritance
o Multilevel Inheritance
o Hierarchical Inheritance
1/10/2018 28
OOPS CONCEPTS
CLASS A
CLASS B
CLASS A
CLASS B
CLASS C
CLASS A
CLASS B CLASS C
Single
Multilevel
Hierarchical

class Animal {
Void eat() {
System.out.println("eating..."); }
}
class Dog extends Animal {
void bark() {
System.out.println("barking..."); }
}
class TestInheritance {
public static void main(String args[]) {
Dog d=new Dog();
d.bark();
d.eat();
}} /* O/P - barking…
eating… */
29
OOPS CONCEPTS
Example for Single Inheritance:

class Animal {
void eat() {
System.out.println("eating...");
} }
class Dog extends Animal{
void bark() {
System.out.println("barking...");
} }
class Cat extends Animal{
void meow() {
System.out.println("meowing...");
} }
class TestInheritance3{
public static void main(String args[]){
Cat c=new Cat();
c.meow();
c.eat(); } } /* O/P - meowing…
eating… */
30
OOPS CONCEPTS
Example for Multilevel and Hierarchical Inheritance:
class Animal {
void eat() {
System.out.println("eating...");
} }
class Dog extends Animal {
void bark() {
System.out.println("barking...");
} }
class BabyDog extends Dog {
void weep() {
System.out.println("weeping...");
} }
class TestInheritance2 {
BabyDog d=new BabyDog();
d.weep();
d.eat(); } } /* O/P - weeping…
eating… */

Encapsulation :
Encapsulation in java is a process of wrapping data and the methods together
into a single unit.
The Java Bean class is the example of fully encapsulated class.
Example:
1/10/2018 31
OOPS CONCEPTS
//save as Test.java
package com.pack1;
class Test{
public static void main(String[] args)
{
Student s=new Student();
s.setName("vijay");
System.out.println(s.getName());
}
} // O/P - vijay
//save as Student.java
package com.pack;
public class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name=name
} }

Access Modifiers:
It specifies accessibility (scope) of a data member, method, constructor or
class.
There are 4 types of access modifiers:
o Private : Accessible only within class.
o Default : Accessible only within package.
o Protected : Accessible within package and outside the package but
through inheritance only.
o Public : Accessible everywhere. It has the widest scope among all other
modifiers.
1/10/2018 32
OOPS CONCEPTS

Polymorphism:
It is a concept by which we can perform a single action by different ways.
o Types of Polymorphism:
• Compile time polymorphism
• Runtime polymorphism.
o It perform in java by method overloading and method overriding.
1/10/2018 33
OOPS CONCEPTS

Method Overloading:
A class has multiple methods having same name but different in parameters.
It increases the readability of the program
Example:
1/10/2018 34
OOPS CONCEPTS
class Adder {
static int add(int a,int b) {
return a+b; }
static int add(int a,int b,int c) {
return a+b+c; }
}
class TestOverloading1 {
System.out.println(Adder.add(11,11)); // O/P – 22
System.out.println(Adder.add(11,11,11)); // O/P - 33
}}

Method Overriding:
Subclass provides the specific implementation of the method that has been
provided by one of its parent class.
Example:
1/10/2018 35
OOPS CONCEPTS
class Vehicle {
Void run() {
System.out.println("Vehicle is running"); }
}
class Bike2 extends Vehicle {
void run() {
System.out.println("Bike is running safely"); }
Vehicle obj = new Bike2();
obj.run();
} // O/P – Bike is running safely

Abstraction:
It is the process of hiding certain details and only show essential features
of the object.
o Abstraction in Java is achieved by using abstract class and interface.
o Abstract class in Java:
A class that is declared as abstract is known as abstract class.
It needs to be extended and its method implemented. It cannot be instantiated.
1/10/2018 36
OOPS CONCEPTS
Example: abstract class A{}

Example for Abstract class:
1/10/2018 37
OOPS CONCEPTS
abstract class Bank {
abstract int getRateOfInterest();
}
class SBI extends Bank {
int getRateOfInterest() {
return 9; }
}
class PNB extends Bank{
int getRateOfInterest() {
return 10; }
}
class TestBank {
Bank b;
b=new SBI();
System.out.println("Rate of Interest is: "+b.getRateOfInterest()+" %");
b=new PNB();
System.out.println("Rate of Interest is: "+b.getRateOfInterest()+" %");
}} /* O/P - Rate of Interest is: 9 %
Rate of Interest is: 10 % */

Interface:
It is an abstract type that is used to specify a behaviour that classes must
implement.
Interfaces are declared using the interface keyword, and may only contain method
signature and constant declarations. All methods of an Interface do not contain
implementation (method bodies).
Advantages of interface:
o Used to achieve abstraction
o Support the functionality of multiple inheritance.
1/10/2018
38
OOPS CONCEPTS

interface printable{
void print();
}
class A1 implements printable {
public void print() {
System.out.println("Hello"); }
public static void main(String args[])
{
A1 obj = new A1();
obj.print();
} } // O/P - Hello
1/10/2018 39
OOPS CONCEPTS
Example for Interface:

Arrays:
o It is an indexed collection of fixed number of homogeneous data elements.
Once created with some size, we can’t alter the size.
o It can store both primitive data and objects.
o Represent multiple values with a single variable. So that reusability of the code
will be improved.
o A specific element in an array is accessed by its index.
o We can add elements into array and can’t insert an element into specified
index of an array.
o It may have one or more dimensions.
1/10/2018
ARRAYS

Single dimension arrays:
12/01/2017
ARRAYS
Program: Average an array of values:
class Average
{
double nums[] = {10.1, 11.2, 12.3, 13.4, 14.5};
double result = 0;
int i;
for(i=0; i<5; i++)
result = result + nums[i];
System.out.println("Average is " + result / 5);
}
} // O/P – Average is 12.29..
Syntax : type[] var-name; or
type var-name[]; or
type []var-name;
Example : int[] a = new int[2];
a[0]= 10;
a[1]= 20;
int a[] = {10, 20};
int []a = new int[]{10,20};

Two-dimensional arrays:
o These are arrays of arrays.
o To declare a two dimensional array variable,
specify each additional index using another
set of square brackets.
1/10/2018
ARRAYS
Program: 2D Print
Class twodimensional
{
int arr[][] = {{1,2,3},{4,5,6},{7,8,9}};
for (int i=0; i< 3 ; i++) {
for (int j=0; j < 3 ; j++)
System.out.print(arr[i][j] + " ");
System.out.println();
}
}
}
/* O/P - 1 2 3
4 5 6
7 8 9 */
Syntax : type[][] var-name; or
type var-name[][];
Example : int[][] a = new int[2][3];
int a[][] = {{10, 20},{30,40}};

String:
o It is an object that represents a sequence of characters.
o The CharSequence interface is used to represent sequence of characters. It
is implemented by String, StringBuffer and StringBuilder classes.
o Objects of String are immutable and fixed in length.
o The java.lang.String class is used to create string object.
o It uses to make Java more memory efficient.
o It is used to have constants in program.
1/10/2018
STRING

Two ways to create String object: (With ‘new’ or without ‘new’)
1. By string literal 2. By new keyword
Syntax: String s=“Welcome"; String s=new String("Welcome");
Example:
12/01/2017 44
STRINGS
public class StringExample {
String s1="java"; //creating string by java string literal
char ch[]={'s','t','r','i','n','g','s'};
String s2=new String(ch); //converting char array to string
String s3=new String("example"); //creating java string by new keyword
System.out.println(s1); // O/P - java
System.out.println(s2); // O/P - strings
System.out.println(s3); // O/P - example
}}

1/10/2018
STRINGS
Methods of String:
Modifier and
Type
Method Modifier and
Type
Method
public char charAt(int index) public boolean contains(CharSequence s)
public int length() public boolean equals(Object another)
public int indexOf(int ch) public String substring(int beginIndex)
public int indexOf(int ch, int
fromIndex)
public String substring(int beginIndex,
endIndex)
public int indexOf(String substring) public String concat(String str)
public int indexOf(String substring,
int fromIndex)
public String replace(char old, char
new)

1/10/2018
STRINGS
Methods of String: (Continue..)
Modifier and
Type
Method Modifier and
Type
Method
public String replace(CharSequence old,
CharSequence new)
public String trim()
public String intern() public String[] split(String regex)
public String toLowerCase() public String[] split(String regex, int
limit)
public String toLowerCase(Locale l) static String format(String format,
Object… args)
public String toUpperCase() static String format(Locale l, String
format, Object... args)
public String toUpperCase(Locale l) static String valueOf(int value)

Example for methods in String:
12/01/2017 47
STRINGS
public class Test {
String s= "Snipe IT Solutions";
System.out.println("length = " + s.length()); // O/P – length = 18
System.out.println("At 3rd position = " + s.charAt(3)); // O/P - At 3rd position = p
System.out.println("Substring = " + s.substring(3,5)); // O/P - Substring = pe
String s1 = "Snipe";
String s2 = "Tutorials";
System.out.println("Concatenated string = " + s1.concat(s2)); /* O/P - Concatenated string =
Snipe Tutorials */
System.out.println("Index of a = " + s.indexOf('s',1)); // O/P - Index of a = 17
int out1 = s2.compareTo(s1);
System.out.println("If s1 = s2 " + out1); // O/P - If s1 = s2 1
System.out.println("Changing to upper Case = " + s1.toUpperCase()); /* O/P - Changing to upper
Case = SNIPE */
String s3 = "SNYPE".replace(‘Y' ,’I') ;
System.out.println("Replaced Y with I -> " + s3); // O/P - Replaced Y with I -> SNIPE
} }

StringBuffer:
o Objects of String are mutable and not fixed in length and should be created
only with “new” operator.
o Every method present in StringBuffer is synchronized.
o Java StringBuffer class is thread-safe i.e. multiple threads cannot access it
simultaneously. So it is safe and will result in an order.
o It increases waiting time of threads. Hence relatively performance is low.
o StringBuffer defines three constructors:
1/10/2018
• StringBuffer( ) Ex: StringBuffer s = new StringBuffer();
• StringBuffer(int size) Ex: StringBuffer s = new StringBuffer(10);
• StringBuffer(String str) Ex: StringBuffer s = new StringBuffer("SNIPE”);
STRINGS

Important Methods of StringBuffer class:
1/10/2018
Modifier and Type Method Modifier and
Type
Method
public synchronized
StringBuffer
append(String s) public int capacity()
public synchronized
StringBuffer
insert(int offset, String s) public char charAt(int index)
public synchronized
StringBuffer
replace(int startIndex,
int endIndex, String str)
public int length()
public synchronized
StringBuffer
delete(int startIndex, int
endIndex)
public String substring(int
beginIndex)
public synchronized
StringBuffer
reverse() public String substring(int
beginIndex,
int endIndex)
STRINGS

Example for methods in StringBuffer class:
1/10/2018
public class Test {
StringBuffer sb=new StringBuffer("SNIPE ");
System.out.println(sb.append("Solutions")); // O/P – SNIPE Solutions
System.out.println(sb.insert(5," IT")); // O/P – SNIPE IT Solutions
System.out.println(sb.replace(10,11,"a")); // O/P - SNIPE IT Salutions
System.out.println(sb.delete(17,18)); // O/P - SNIPE IT Salution
System.out.println(sb.charAt(4)); // O/P - E
System.out.println(sb.substring(6)); // O/P - IT Salution
System.out.println(sb.substring(6, 8)); // O/P - IT
System.out.println(sb.reverse()); // O/P - noitulaS TI EPINS
System.out.println(sb.length()); // O/P - 17
System.out.println(sb.capacity()); // O/P - 22
}
}
STRINGS

StringBuilder:
o The Java StringBuilder class is same as StringBuffer class except that it is non-
synchronized and is not thread-safe
o StringBuilder is more efficient than StringBuffer.
o Threads are not required to wait to operate in StringBuilder object. Hence
relatively performance is high.
o StringBuilder defines three constructors:
1/10/2018
• StringBuilder( ) Ex: StringBuilder s = new StringBuilder();
• StringBuilder(int length) Ex: StringBuilder s = new StringBuilder(10);
• StringBuilder(String str) Ex: StringBuilder s = new StringBuilder("SNIPE”);
STRINGS

Important Methods of StringBuilder class:
1/10/2018
Modifier and Type Method Modifier and
Type
Method
public StringBuilder append(String s) public int capacity()
public StringBuilder insert(int offset, String s) public char charAt(int index)
public StringBuilder replace(int startIndex,
int endIndex, String str)
public int length()
public StringBuilder delete(int startIndex, int
endIndex)
public String substring(int
beginIndex)
public StringBuilder reverse() public String substring(int
beginIndex,
int endIndex)
STRINGS

Example for methods in StringBuilder class:
1/10/2018
public class Test {
StringBuilder sb=new StringBuilder("SNIPE ");
System.out.println(sb.append("Solutions")); // O/P – SNIPE Solutions
System.out.println(sb.insert(5," IT")); // O/P – SNIPE IT Solutions
System.out.println(sb.replace(10,11,"a")); // O/P - SNIPE IT Salutions
System.out.println(sb.delete(17,18)); // O/P - SNIPE IT Salution
System.out.println(sb.charAt(4)); // O/P - E
System.out.println(sb.substring(6)); // O/P - IT Salution
System.out.println(sb.substring(6, 8)); // O/P - IT
System.out.println(sb.reverse()); // O/P - noitulaS TI EPINS
System.out.println(sb.length()); // O/P - 17
System.out.println(sb.capacity()); // O/P - 22
}}
STRINGS

String vs StringBuffer vs StringBuilder in Java
Example:
1/10/2018
class Test {
public static void concat1(String s1) {
s1 = s1 + "IT Solutions"; }
public static void concat2(StringBuffer s2) {
s2.append(" IT Solutions "); }
public static void concat3(StringBuilder s3) {
s3.append(" IT Solutions "); }
String s1 = "SNIPE";
concat1(s1); // s1 is not changed
System.out.println("String: " + s1); // O/P – String: SNIPE
StringBuffer s2 = new StringBuffer("SNIPE ");
concat2(s2); // s2 is changed
System.out.println("StringBuffer: " + s2); // O/P – StrigBuffer: SNIPE IT Solutions
StringBuilder s3 = new StringBuilder("SNIPE ");
concat3(s3); // s3 is changed
System.out.println("StringBuilder: " + s3); // O/P – StrigBuilder: SNIPE IT Solutions
}}
STRINGS

Collections:
o Collections in java is a framework that provides an architecture to store and
manipulate the group of objects.
o Collections are growable in nature.
o Collections can hold both homogeneous and heterogeneous elements.
o Difference b/w Collection and Collections is Collections is an utility class present in
java.util.package to define several utility methods (like Sorting, Searching..) for
Collection objects.
o Every collection class is implemented based on some standard data structure.
Hence readymade method support is available for every requirement.
1/10/2018
COLLECTIONS

1/10/2018
COLLECTION FRAMEWORK
Hierarchy of Collection Framework

Key Interfaces of Collection Framework:
1) Collection Interface :
o Collection represents a single unit of objects. i.e a group. and To represent a group
of individual objects as single entity.
o Collection interface defines the most common methods which are applicable for any
Collection object and is considered as root interface of Collection Framework.
1/10/2018

1/10/2018
Methods of Collection Interface:
Modifier and
Type
Method Modifier and
Type
Method
public boolean add(Object element) public boolean contains(Object
element)
public boolean addAll(Collection c) public boolean containsAll(Object
element)
public boolean remove(Object element) public int size()
public boolean removeAll(Collection c) public void clear()
public boolean retainAll(Collection c) public Iterator iterator()
public boolean isEmty() public Object[] toArray()
public boolean equals(Object element) public int hashCode()

2) List Interface :
o List interface extends the Collection interface to provides the functionality to
store and manage a sequence of items.
o It contains methods to insert and delete elements in index basis. It is a factory of
ListIterator interface
o List is useful for represent a group of individual objects as a single entity where
duplicates are allowed and insertion order preserved.
1/10/2018

1/10/2018
o Declaration of List Interface:
public interface List<E> extends Collection<E>
o Methods of List Interface:
Modifier and
Type
Method Modifier and
Type
Method
public void add(int index, Object
element)
public object remove(int index)
public boolean addAll(int index,
Collection c)
ListIterator listIterator()
public object get(int index) ListIterator listIterator(int index)
public object set(int index, Object
element)

ArrayList:
o Java ArrayList class uses a dynamic array for storing the elements.
• It inherits AbstractList class and implements List interface.
o The important points about Java ArrayList class are:
• It can contain duplicate elements.
• It class maintains insertion order.
• It is non synchronized.
• The underlined date structure is Resizable Array or Growable Array.
• It allows Heterogeneous objects.
• It allows Random Access because array works at the index basis.
o In Java ArrayList class, manipulation is slow because a lot of shifting needs to
be occurred if any element is removed from the array list.
1/10/2018

public class ArrayList<E> extends AbstractList<E> implements List<E>
Constructors of ArrayList:
1/10/2018
Hierarchy of ArrayList class
Declaration of ArrayList:
• ArrayList()
• ArrayList(Collection c)
• ArrayList(int capacity)

1/10/2018
Methods of ArrayList:
Modifier and
Type
Method Modifier and
Type
Method
public boolean addAll(Collection c) public int lastIndexOf(Object ele)
public boolean add(Object ele) public int indexOf(Object ele)
public boolean addAll(int index,
Collection c)
public Object[] toArray()
element)
public Object[] toArray(Object[] a)
public void clear() public Object clone()
public void trimToSize()

Example for ArrayList:
12/01/2017 64
import java.util.*;
Class ArrayListDemo {
ArrayList I = new ArrayList();
I.add("A");
I.add(10);
I.add("A");
I.add(null);
System.out.println(I); // O/P – [A, 10, A, null]
I.remove(2);
System.out.println(I); // O/P – [A, 10, null]
I.add("2", "B");
I.add("C");
System.out.println(I); // O/P – [A, 10, B, null, C]
}}

LinkedList:
o Java LinkedList class uses doubly linked list to store the elements. It provides
a linked-list data structure. It inherits the AbstractList class and implements
List and Deque interfaces.
o The important points about Java LinkedList are:
• It can contain duplicate elements.
• It maintains insertion order.
• It is non synchronized.
• In Java LinkedList class, manipulation is fast because no shifting needs to be
occurred.
• Java LinkedList class can be used as list, stack or queue.
1/10/2018

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E> ,
Deque<E>, Cloneable, Serializable
Constructors of LinkedList:
1/10/2018
Hierarchy of LinkedList class
Declaration of LinkedList:
• LinkedList()
• LinkedList(Collection c)

1/10/2018
Methods of LinkedList:
Modifier and
Type
Method Modifier and
Type
Method
public boolean contains(Object o) public int size()
public boolean add(Object o) public int indexOf(Object o)
public boolean remove(Object o) public int lastIndexOf(Object o)
element)
public Object getFirst()
public void addFirst(Object o) public Object getLast()
public void addLast(Object o)

Example for LinkedList:
12/01/2017 68
import java.util.*;
Class LinkedListDemo {
ArrayList I = new ArrayList();
I.add("A");
I.add(10);
I.add("A");
I.add(null);
System.out.println(I); // O/P – [A, 10, A, null]
I.remove(2);
System.out.println(I); // O/P – [A, 10, null]
I.add("2", "B");
I.add("C");
System.out.println(I); // O/P – [A, 10, B, null, C]
}}

Vector:
o Vector implements List interface and maintains insertion order.
o Vector is synchronized. Hence Vector class is mainly useful for multithreaded
environment, since all the methods implemented in Vector class.
o It allows Duplicate objects, Heterogeneous objects and ‘null’ insertion.
o The Vector class implements a growable array of objects. Vector doubles the array
size if total number of elements exceeds than its capacity.
1/10/2018

Vector<String> myVector = new Vector<String>();
Constructors of Vector:
1/10/2018
Declaration of Vector:
• Vector()
• Vector(int size)
• Vector(int size, int incr)
• Vector(Collection c)

1/10/2018
Methods of Vector:
Modifier and
Type
Method Modifier and
Type
Method
public boolean add(Object o) public int size()
public boolean remove(Object o) public int capacity()
public void add(int index, Object o) public Object get(int index)
public void addElement(Object o) public Object elementAt(int index)
public void remove(Object o) public Object firstElement()
Public void removeElement(Object o) public Object lastElement()

Example for Vector:
12/01/2017 72
import java.util.*;
Class VectorDemo {
Vector v = new Vector();
System.out.println(v.capacity()); // O/P – [ 10]
for(int i=0;i<10;i++) {
v.addElement(i);
}
v.addElement("A");
v.addElement(v);
}}

Stack:
o Stack class is a collection that is based on the Last In First Out (LIFO) principle.
o Constructor of Stack:
o Methods of Stack:
1/10/2018
• Stack()
Modifier and
Type
Method Modifier and
Type
Method
public Object push(Object ele) public Object peek()
public Object pop() public int search(Object ele)

Example for Stack:
12/01/2017 74
import java.util.*;
Class StackDemo {
Stack s = new Stack();
s.push("A");
s.push("B");
s.push("C");
System.out.println(s); // O/P – [ A,B,C]
System.out.println(s.search("A")); // O/P – [ 3]
System.out.println(s.search("Z")); // O/P – [ -1]
}
}

3) Set Interface:
o Set interface is a generic interface that extends the Collection interface.
o It provides the functionality to store and manage a set of elements and does not
provide any additional methods.
o Set is useful for represent a group of individual objects as a single entity where
duplicates are not allowed and insertion order not preserved.
1/10/2018

HashSet:
o Java HashSet class is used to create a collection that uses a hash table for storage.
It inherits the AbstractSet class and implements Set interface.
o The important points about Java HashSet class are:
• It stores the elements by using a mechanism called hashing.
• It contains unique elements only and ‘null’ insertion is possible.
• It allows Heterogeneous objects and not allow Duplicate objects.
• It implements Serializable and Cloneable interface but not Random Access.
• Insertion order is not preserved and all objects will be inserted on hash-code
of objects.
1/10/2018

public class HashSet<E> extends AbstractSet<E> implements Set<E>,
Cloneable, Serializable
Constructors of HashSet:
1/10/2018
Hierarchy of HashSet
Declaration of HashSet:
• HashSet()
• HashSet(Collection c)
• HashSet(int capacity)

1/10/2018
Methods of HashSet:
Modifier and
Type
Method Modifier and
Type
Method
public boolean contains(Object o) public int size()
public boolean add(Object o) public void clear()
public boolean remove(Object o) public Object clone()
public boolean isEmpty() public Iterator iterator()

Example for HashSet:
12/01/2017 79
import java.util.*;
class HashSetDemo {
HashSet h = new HashSet();
h.add("A");
h.add("B");
h.add(null);
h.add(10);
System.out.println(h.add("B")); // O/P – false
System.out.println(h); // O/P – [null, A, B, 10]
}
}

Linked HashSet:
o Java LinkedHashSet class is a Hash table and Linked list implementation of the set
interface. It inherits HashSet class and implements Set interface.
o The important points about Java LinkedHashSet class are:
• It contains unique elements only like HashSet.
• It provides all optional set operations, and permits null elements.
• It maintains insertion order.
• It is best choice to develop cache based applications, where duplicates are
not allowed and insertion order must be preserved.
1/10/2018

public class LinkedHashSet<E> extends HashSet<E> implements Set<E>,
Cloneable, Serializable
Constructors of LinkedHashSet:
1/10/2018
Hierarchy of LinkedHashSet
Declaration of LinkedHashSet:
• HashSet()
• HashSet(Collection c)
• LinkedHashSet(int capacity)
• LinkedHashSet(int capacity, float fillRatio)

Example for LinkedHashSet:
12/01/2017 82
import java.util.*;
class LinkedHashSetDemo {
LinkedHashSet h = new LinkedHashSet();
h.add("A");
h.add("B");
h.add(null);
h.add(10);
System.out.println(h.add("B")); // O/P – false
System.out.println(h); // O/P – [A, B, null, 10]
}
}

Sorted Set:
o It represent a group of individual objects according to some sorting order.
o It allows Homogeneous objects and not allow Duplicate objects.
o Default natural sorting order for numbers is Ascending order and for String is
Alphabetic order.
o Methods of SortedSet:
1/10/2018
Modifier and
Type
Method Modifier and
Type
Method
public Object first() SortedSet tailSet(Object obj)
public Object last() SortedSet subSet(Object obj1,
Object obj2)
SortedSet headSet(Object obj) Comparator comparator()

Example for SortedSet:
12/01/2017 84
import java.util.*;
class SortedSetDemo {
SortedSet h = new TreeSet();
h.add("A");
h.add("C");
h.add("D");
System.out.println(h.add("B")); // O/P – true
System.out.println(h); // O/P – [A, B, C, D]
}
}

TreeSet:
o Java TreeSet class implements the Set interface that uses a tree for storage. It
inherits AbstractSet class and implements NavigableSet interface.
o The objects of TreeSet class are stored in ascending order.
o The important points about Java TreeSet class are:
• It contains unique elements only like HashSet.
• It access and retrieval times are quiet fast.
• It allows Null Insertion once only and not allow Duplicate objects and
Heterogeneous objects.
• Insertion order not preserved, but all objects will be inserted according to some
sorting order.
• Underlying data structure for TreeSet is Balanced Tree.
1/10/2018

public class TreeSet<E> extends AbstractSet<E> implements
NavigableSet<E>, Cloneable, Serializable
Constructors of TreeSet:
1/10/2018
Hierarchy of TreeSet
Declaration of TreeSet:
• TreeSet()
• TreeSet(Collection c)
• TreeSet(Comparator c)
• TreeSet(Sorted Set s)

Example for TreeSet:
12/01/2017 87
import java.util.*;
class SortedSetDemo {
TreeSet h = new TreeSet();
h.add("A");
h.add("C");
h.add("D");
System.out.println(h.add("B")); // O/P – true
System.out.println(h); // O/P – [A, B, C, D]
}
}

4) Queue Interface:
o Queue Interface extends the Collection interface to provide an implementation of a
queue and provides the functionality to add, remove, access and examine queue
elements.
o Typically, queues implement a first-in first out behaviour and elements can be
removed only from the head.
o Queue is useful for represent a group of individual objects prior to processing.
1/10/2018

Example for Queue Interface:
12/01/2017 89
import java.util.*;
class TestCollection {
PriorityQueue<String> queue=new PriorityQueue<String>();
queue.add("Monika");
queue.add("Darshan");
queue.add("Praveen");
queue.add("Suresh");
System.out.println("head:"+queue.element());
System.out.println("head:"+queue.peek());
System.out.println("iterating the queue elements:");
Iterator itr=queue.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
// Continued
queue.remove();
queue.poll();
System.out.println("after removing two elements:");
Iterator<String> itr2=queue.iterator();
while(itr2.hasNext()){
System.out.println(itr2.next());
} } }
/* O/P - head:Darshan
head:Darshan
iterating the queue elements:
Darshan
Monika
Praveen
Suresh
after removing two elements:
Praveen
Suresh */

5) Map Interface:
o The Map interface is a generic interface that provides a way to store key/value
pairs. A map is an object that maps keys to values. Keys are unique and are used to
identify values.
o Both key and value are objects, duplicated keys are not allowed but values can be
duplicated.
1/10/2018

Example for Map Interface:
12/01/2017 91
import java.util.*;
class MapInterfaceExample {
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(102, "Darshan");
map.put(101, "Monika");
map.put(103, "Praveen");
map.put(103, "Suresh");
for(Map.Entry m:map.entrySet()) {
System.out.println(m.getKey()+" "+m.getValue());
} }
} /* O/P - 101 Monika
102 Darshan
103 Suresh */

Summarization of principal classes in Java collections framework:
1/10/2018
Principal
collection class
Base class Base
interfaces
Allow duplicate
elements?
Ordered? Sorted?
ArrayList<E> AbstractList<E> List<E> Yes Yes No
LinkedList<E> AbstractSequent
ialList<E>
List<E>;
Deque<E>
Yes Yes No
Vector<E> AbstractList<E> List<E> Yes Yes No
HashSet<E> AbstractSet<E> Set<E> No No No
LinkedHashSet<E> HashSet<E> Set<E> No Yes No
TreeSet<E> AbstractSet<E> Set<E>;
NavigableSet<E>;
SortedSet<E>
No Yes Yes
Queue<E> AbstratQueue<E> Collection<E> Yes Yes No

Cursors:
o Cursors are used to retrieve objects one by one from the collection.
o There are three types of cursors:
1/10/2018
CURSORS
Property 1. Enumeration 2. Iterator 3. ListIterator
Applicable for Only legacy classes Any Collection classes Only List classes
Movement Only forward direction Only forward direction Both forward and backward direction
Accessibility Only read access Both read and remove Read, Remove, Replace and addition of
new object
How to get it? By 2 methods
1. hasMoreElements()
2. nextElement()
By 3 methods
1. hasNext()
2. next()
3. remove()
By 9 methods
1. hasNext()
2.next()
3.nextIndex()
4.hasPrevious()
5.previous()
6. previousIndex()
7. remove()
8. set(Object new)
9. add(Object new)

Example for Enumeration Cursor:
12/01/2017 94
import java.util.*;
public class MyEnumeration {
public static void main(String a[]) {
Vector<String> lang = new Vector<String>();
Enumeration<String> en = null;
lang.add("JAVA");
lang.add("JSP");
en = lang.elements();
while(en.hasMoreElements()) {
System.out.println(en.nextElement());
} }
} /* O/P - JAVA
JSP */

Example for Iterator Cursor:
12/01/2017 95
import java.util.*;
public class MapInterfaceExample
{
public static void main(String[] args)
{
List<String> myList = new ArrayList<String>();
myList.add("Java");
myList.add(“JSP");
myList.add(“Servlet");
System.out.println(“Before remove:");
System.out.println(myList);
Iterator<String> itr = myList.iterator();
while(itr.hasNext())
// Continued
{
String removeElem = “JSP";
if(removeElem.equals(itr.next())) {
itr.remove();
}
}
System.out.println("After remove:");
System.out.println(myList);
}
} /* O/P - Before remove:
[Java, JSP, Servlet]
After remove:
[Java, Servlet] */

Example for Iterator Cursor:
12/01/2017 96
import java.util.*;
public class MyListIterator {
public static void main(String a[]) {
List<Integer> li = new ArrayList<Integer>();
ListIterator<Integer> litr = null;
li.add(25);
li.add(90);
li.add(35);
litr=li.listIterator();
System.out.println(“Forward direction");
while(litr.hasNext()) {
System.out.println(litr.next());
}
// Continued
System.out.println(“Backward direction");
while(litr.hasPrevious()) {
System.out.println(litr.previous());
}
}
} /* O/P - Forward direction
25
95
30
Backward direction
30
95
25 */

Generics:
o Generics are given the ability to create generalized classes, interfaces and
methods by operating through references of type Object.
o It was added in Java 5 to provide compile-time type checking and removing risk
of ClassCastException.
o It provides compile-time type safety that allows programmers to catch invalid
types at compile time and also expand ability to reuse code.
o Advantages:
• Type-safety : We can hold only a single type of objects in generics.
It doesn’t allow to store other objects.
• Type casting is not required : There is no need to typecast the object.
• Compile-Time Checking : It is checked at compile time so problem will not
occur at runtime.
97
GENERICS
Syntax: ArrayList<String>

Example for Generics:
12/01/2017 98
import java.util.*;
class TestGenerics1{
ArrayList<String> list=new ArrayList<String>();
list.add("rahul");
list.add("jai");
//list.add(32);//compile time error
String s=list.get(1);//type casting is not required
System.out.println("element is: "+s);
Iterator<String> itr=list.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
} } }

MULTI-THREADING
Multithreading:
o Multithreading in java is a process of executing multiple threads
simultaneously.
o Both multiprocessing and multithreading are used to achieve multitasking.
Process Threads
A process is a collection of one or
more threads and associated system
resources.
Threads are light-weight processes
within a process .
Process can be divided into multiple
threads
Threads cannot be sub divided.
Each process has its own memory
space
Threads of the same process share
a common memory space
It is difficult to create a process It is easy to create a thread.

Multitasking is a process of executing multiple tasks simultaneously.
The multitasking types are:
1) Process-based Multitasking (Multiprocessing):
• Each process have its own address in memory i.e. each process allocates
separate memory area.
• Process is heavyweight.
• Cost of communication between the process is high.
• Switching from one process to another require some time for saving and
loading registers, memory maps, updating lists etc.
2) Thread-based Multitasking (Multithreading):
• Threads share the same address space.
• Thread is lightweight.
• Cost of communication between the thread is low.
MULTI-THREADING

Life cycle of the thread:
During the life time of a thread, there are many states it can enter.
They include :
o New
o Runnable
o Running
o Non-Runnable
o Terminated
MULTI-THREADING

By extend thread class By implementing Runnable
interface
class Test extends Thread
{
public void run() {
Sytem.out.println(" running..."); }
public static void main(String args[])
{
Test t1=new Test();
t1.start();
}
}
// O/P - running…
class Test2 implements Runnable
{
public void run() {
System.out.println(“running...");
}
Test2 m1=new Test2();
Thread t1 =new Thread(m1);
t1.start();
}
}
O/P - running...
Creation of Thread:
MULTI-THREADING

sleep() join() Yield()
Used to sleep a thread
for the specified amount
of time.
join() waits for a
thread to die.
Yield() causes the
current thread to
temporarily pause its
execution
Syntax:
1.public static void
sleep(long miliseconds)
throws
InterruptedException
2. public static void
sleep(long miliseconds,
int nanos) throws
Syntax:
1.public static
join()throws
2.public static
join()(long miliseconds)
throws
Syntax:
1. public static native
void yield()
Method used in Thread:
MULTI-THREADING

Naming Thread :
The Thread class provides methods to change and get the name of a thread. By
default, each thread has a name i.e. thread-0, thread-1 and so on. By we can
change the name of the thread by using setName() method.
The syntax of setName() and getName() methods are:
1. public String getName(): used to return the name of a thread.
2. public void setName(String name): used to change the name of a thread.
MULTI-THREADING

Thread Priority:
Each thread have a priority. Priorities are represented by a number between
1 and 10. In most cases, thread scheduler schedules the threads according to
their priority (known as pre-emptive scheduling). But it is not guaranteed
because it depends on JVM specification that which scheduling it chooses.
The Thread class defines several priority constants:
1. MIN_PRIORITY=1
2. NORM_PRIORITY=5
3. MAX_PRIORITY=10
The default setting is NORM_PRIORITY
MULTI-THREADING

Synchronization:
o Synchronization in java is the capability to control the access of multiple
threads to any shared resource.
o Synchronization is better in case we want only one thread can access the
shared resource at a time.
o Synchronization is mainly used to prevent thread interference and
consistency problem.
There are two types of synchronization:
1. Process Synchronization
2. Thread Synchronization
MULTI-THREADING

Thread synchronization:
Types of Thread synchronization:
1. Mutual Exclusive
It helps to keep threads from interfering with one another while sharing data.
a) Synchronized method
b) Synchronized block
c) Static synchronization
2. Co-Operation(Inter-thread communication)
MULTI-THREADING

Example for Synchronized Method:
class Table{
synchronized void printTable(int n) {
for(int i=1;i<=5;i++)
{ System.out.println(n*i);
try {
Thread.sleep(400);
} catch(Exception e) {
System.out.println(e);
} } } }
class MyThread1 extends Thread{
Table t;
MyThread1(Table t){ this.t=t; }
public void run() {
t.printTable(5); } }
public class Demo{
Table obj = new Table(); //only one object
MyThread1 t1=new MyThread1(obj);
t1.start();
} }
MULTI-THREADING

Synchronized method Synchronized block
If declare any method as synchronized,
it is known as synchronized method.
Synchronized method is used to lock an
object for any shared resource.
Synchronized block can be used to
perform synchronization on any specific
resource of the method.
Syntax:
Synchronized void methodname()
Syntax:
synchronized (object reference
expression)
{
//code block
}
MULTI-THREADING

Static synchronization:
To make any static method as synchronized, the lock will be on the class
not on object.
Deadlock:
Deadlock can occur in a situation when a thread is waiting for an object lock,
that is acquired by another thread and second thread is waiting for an object
lock that is acquired by first thread. Since, both threads are waiting for each
other to release the lock, the condition is called deadlock.
MULTI-THREADING

Inter-thread Communication / Co-operation:
o It is all about allowing synchronized threads to communicate with each other.
o It 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.
o It is implemented by following methods of Object class:
• wait()
• notify()
• notifyAll()
MULTI-THREADING

Wait() Notify() NotifyAll()
Suspends
execution of
current thread
It moves only one waiting
thread from waiting
state to runnable state
It moves all waiting
thread from waiting
state to runnable state
Only used in
synchronised
context
Only used in
synchronised context
Only used in
synchronised context
It releases lock It will give up the lock It will give up the lock
MULTI-THREADING

Exception Handling:
o Exception is an event that interrupts the normal flow of the program that results
to abnormal termination of program .
o In java exceptional handling is a mechanism to handle the runtime errors so that
normal flow of the application can be maintained.
o Maintains the normal flow of the application.
o Gives alternate way to normal flow. Or Graceful termination to the program.
o Separates the normal code & risky code
90
Example:
statement 1;
statement 2;
statement 3; //exception occurs
statement 4;
statement 5;
There are 5 statements in program and
there occurs an exception at statement
3, rest of the code will not be executed
i.e. statement 4 & 5 will not run. If we
perform exception handling, rest of the
statement will be executed..
EXCEPTION HANDLING

1/10/2018 114
Exception Hierarchy:
EXCEPTION HANDLING

1/10/2018 115
Types of Exception :
The sun micro system says there are three types of exceptions:
Checked, Unchecked and Error.
There are mainly two types of exceptions: where error is considered as
unchecked exception.
Checked Exception Unchecked Exception
Subclass of Exception Subclass of RunTimeException & Errors
Checked by compiler whether you are
handling or not.
Not checked by compiler whether you
are handling or not.
Force to developer to handle by
either writing try/catch or throws.
Do not force to developer to handle.
Also called as Caught Exceptions Also called as Uncaught Exceptions
EXCEPTION HANDLING

Keywords:
o try { }
try block is used to enclose the code that might throw an exception.
It must be used within the method.
o catch { }
catch block is used to statement which will catch the arisen exception.
o finally { }
It is a block that is used to execute important code without fail like closing
connection.
EXCEPTION HANDLING

Keywords (Continue.. ):
o throw:
It is used to explicitly throw an exception. throw either checked or
unchecked exception in java.
o throws:
It 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.
Syntax: throw new IOException("sorry device error);
Syntax:
return_type method_name() throws exception_class_name{ //method code}
EXCEPTION HANDLING

Example for try, catch & finally keywords :
class TestBlocks{
try{
int data=25/0;
System.out.println(data);
}
catch(ArithmeticException e) {
System.out.println(e); }
finally {
System.out.println("finally block executes always"); }
System.out.println("rest of the code...");
}
} /* java.lang.ArithmeticException: / by zero
finally block executes always
rest of the code */
Rule: For each try block there can be zero or more catch blocks, but only one finally block.
EXCEPTION HANDLING

Example for throw keyword:
public class TestThrow {
static void validate(int age) {
if(age<18)
throw new ArithmeticException("not valid");
else
System.out.println("welcome to vote");
}
validate(13);
System.out.println("rest of the code...");
}
} /* O/P:
Exception in thread main java.lang.ArithmeticException:not valid */
EXCEPTION HANDLING

1/10/2018
120
throw throws
It is used to explicitly throw
an exception.
It is is used to declare an exception
Checked exception cannot be
propagated using throw only
Checked exception can be propagated with
throws
Throw is followed by an
instance
Throws is followed by class.
Throw is used within the
method.
Throws is used along with method signature.
You cannot throw multiple
exceptions
You can declare multiple exceptions public
void method()throws IOException,
SQLException
Difference b/w throw & throws:
EXCEPTION HANDLING

Regular Expressions:
o The Java Regex or Regular Expression is an API to define pattern for searching or
manipulating strings.
o It is widely used to define constraint on strings such as password and email
validation. We will be able to test our own regular expressions by the Java Regex
Tester Tool.
o Java Regex API provides 1 interface and 3 classe in java.util.regex package.
o Classes and Interface:
java.util.regex package: It provides following classes and interface for regular
expressions.
• MatchResult (I)
• Matcher (C)
• Pattern (C)
• PatternSyntaxException (C)
REG-EX

1/10/2018 122
Matcher©:
o It implements MatchResult(I).
o It is a regex engine i.e. used to perform match operations on a
character sequence.
Methods Description
boolean matches() test whether the regular expression matches the pattern.
boolean find() finds the next expression that matches the pattern.
String group() returns the matched subsequence.
int start() returns the starting index of the matched subsequence.
int end() returns the ending index of the matched subsequence.
REG-EX

1/10/2018 123
Pattern(C):
o It is the compiled version of a regular expression.
o It is used to define a pattern for the regex engine.
Methods Description
static Pattern
compile(String regex)
compiles the given regex and return the instance of
pattern.
Matcher matcher
(CharSequence input)
creates a matcher that matches the given input with
pattern.
String[]
split(CharSequence input)
splits the given input string around matches of given
pattern.
String pattern() returns the regex pattern.
REG-EX

1/10/2018 124
Character(C):
o It is used to match only one out of several characters.
Methods Description
[abc] a, b, or c (simple class)
[^abc] Any character except a, b, or c (negation)
[a-zA-Z] a through z or A through Z, inclusive (range)
[a-d[m-p]] a through d, or m through p: [a-dm-p] (union)
[a-z&&[^bc]] a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]] a through z, and not m through p: [a-lq-z](subtraction)
REG-EX

class RegexExample{
System.out.println("by character classes and quantifiers ...");
System.out.println(Pattern.matches("[789]{1}[0-9]{9}", "9953038949")); // O/P - true
System.out.println(Pattern.matches("[789][0-9]{9}", "9953038949")); // O/P - true
System.out.println(Pattern.matches("[789][0-{9}", "99530389490")); // O/P - false (11 chars)
System.out.println(Pattern.matches("[789][0-9]{9}", "8853038949")); // O/P - true
}
}
Example for Regular Expression:
REG-EX

Annotations:
o It is a tag that represents the metadata i.e. attached with class, interface,
methods or fields to indicate some additional information which can be used by java
compiler and JVM.
o It is an alternative option for XML and java Marker Interfaces.
o Annotations are executed by predefined tool APT(Annotation Processing Tool).
o Types of Annotations:
1. Built-In Java Annotations
2. Custom Annotation
ANNOTATIONS

1.1 Built-In Annotations used in java code
@Override
@SuppressWarnings
@Deprecated
1.2 Built-In Annotations used in other annotation
@Target
@Retention
@Inherited
@Documented
127
ANNOTATIONS

1/10/2018 128
Built-In Annotations:
@Override:
It assures that the subclass method is overriding the parent class method.
If it is not so, compile time error occurs.
@SuppressWarnings:
It is used to suppress warnings issued by the compiler.
@Deprecated:
It marks that this method is deprecated so compiler prints warning.
It informs user that it may be removed in the future versions. So, it is better not to
use such methods.
ANNOTATIONS

1/10/2018 129
Java Custom Annotation:
o Easy to create and use.
o The @interface element is used to declare an annotation.
o Few points for custom annotation signature:
• Method should not have any throws clauses.
• Method should return one of the following:
primitive data types, String, Class, enum or array of these data types.
• Method should not have any parameter.
• It may assign a default value to the method.
Example: @interface MyAnnotation{}
ANNOTATIONS

1/10/2018 130
Types of Custom Annotation:
1. Marker Annotation
2. Single-Value Annotation
3. Multi-Value Annotation
1) Marker Annotation: An annotation that has no method.
The @Override and @Deprecated are marker annotations.
2) Single-Value Annotation: An annotation that has one method.
Example: @interface MyAnnotation{}
Example: @interface MyAnnotation{ int value(); }
ANNOTATIONS

1/10/2018 131
3) Multi-Value Annotation: An annotation that has more than one method.
o Providing the default value.
Example: @interface MyAnnotation {
int value1();
String value2();
}
Example: @interface MyAnnotation {
int value1() default 1;
String value2() default "xyz";
}
ANNOTATIONS

1/10/2018 132
Built-in Annotations used in custom annotations in java are:
@Target, @Retention, @Inherited, @Documented
@Target: It is used to specify at which type, the annotation is used.
The java.lang.annotation.ElementType enum declares many constants to
specify the type of element where annotation is to be applied such as TYPE,
METHOD, FIELD etc. The constants of ElementType enum are:
Element Types Where the annotation can be applied
TYPE class, interface or enumeration
FIELD fields
METHOD methods
CONSTRUCTOR constructors
LOCAL_VARIABLE local variables
ANNOTATION_TYPE annotation type
PARAMETER parameter
ANNOTATIONS

1/10/2018 133
Example: To specify annotation for a class
@Target(ElementType.TYPE)
@interface MyAnnotation{
int value1();
String value2();
}
Example: To specify annotation for a class, methods or fields
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD}) @inter
face MyAnnotation{
int value1();
String value2();
}
ANNOTATIONS

1/10/2018 134
@Retention: It is used to specify to what level annotation will be available.
RetentionPolicy Availability
RetentionPolicy.SOURCE refers to the source code, discarded during compilation.
It will not be available in the compiled class.
RetentionPolicy.CLASS refers to the .class file, available to java compiler but not
to JVM. It is included in the class file.
RetentionPolicy.RUNTIME refers to the runtime, available to java compiler and JVM.
Example: To specify the RetentionPolicy
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface MyAnnotation{
int value1();
String value2();
}
ANNOTATIONS

Java Enum:
o It is a data type that contains fixed set of constants.
o It can be used for days of the week (SUNDAY, MONDAY, TUESDAY,
WEDNESDAY, THURSDAY, FRIDAY and SATURDAY) , directions (NORTH,
SOUTH, EAST and WEST) etc. The java enum constants are static and final
implicitly. It is available from JDK 1.5.
o Advantages of Java enum:
• Improves type safety
• Easily used in switch
• Traversed
• It can have fields, constructors and methods
• It may implement many interfaces but cannot extend any class
because it internally extends Enum class
ENUM

1/10/2018 136
o Enum has constructors. Except of constructors, an Enum is an ordinary class.
o Each name listed within an Enum is actually a call to a constructor
o Enum constructors are only available within the Enum itself
Example for Enum:
ENUM
class EnumExample4 {
enum Season {
WINTER(5), SPRING(10), SUMMER(15), FALL(20);
private int value;
private Season(int value) {
this.value=value;
} }
for (Season s : Season.values())
System.out.print(s+" "+s.value);
} } // O/P - WINTER 5 SPRING 10 SUMMER 15 FALL 20

Java Fundamentals:
1. What is JVM and Is it platform independent?
2. What is difference between JDK and JVM and JRE?
3. Why Java is not pure Object Oriented language?
4. What are principle concepts of OOPS?
5. What is Java Package and which package is imported by default?
6. What is Overloading and Overriding in Java?
7. What is the difference between an Inner Class and a Sub-Class?
8. What is the difference between abstract class and interface?
9. What is static binding and dynamic binding?
10.What is Data Encapsulation and what’s its significance?
FAQ’s

Java Fundamentals: (Continue..)
11. What is Java Bean Class?
12. What are Access modifiers?
13. What’s the benefit of using inheritance?
14. Why multiple Inheritance not supported in Java?
15. What is the diamond problem in inheritance?
16. What is the difference between break and continue statement?
17. What is nested class?
18. How are this() and super() used with Constructor?
19. What is Serialization and Deserialization
20 What is difference between Heap and Stack Memory?
FAQ’s

Array:
1. What do you mean by an Array? How to create?
2. What are advantages and disadvantages of Array?
3. What is the meaning of anonymous array? Explain with an example?
4. What are “jagged” arrays in java?
5. How to copy an array into another array?
6. What is the step to access elements of an array in Java?
7. How to sort an array in Java?
8. What is difference between ArrayIndexOutfOBounds and ArrayStoreException?
9. How to check array contains value or not?
10.Where does array stored in memory?
FAQ’s

String :
1. What is String in Java?
2. What are different ways to create String Object?
3. What is String subSequence method?
4. How to convert String to char and vice versa?
5. How to convert String to byte array and vice versa?
6. Difference between String, StringBuffer and StringBuilder?
7. Why String is immutable or final in Java?
8. What is String Pool?
9. What does String intern() method do?
10.Why String is popular HashMap key in Java?
FAQ’s

Collections :
1. What is Java Collections Framework? List out some benefits of Collections framework?
2. What is the benefit of Generics in Collections Framework?
3. What are the basic interfaces of Java Collections Framework?
4. What are common algorithms implemented in Collections Framework?
5. Why Collection doesn’t extend Cloneable and Serializable interfaces?
6. What is difference between Array and ArrayList? When will you use Array over
ArrayList?
7. What are similarities and difference between ArrayList, Linked List and Vector?
8. Why Map interface doesn’t extend Collection interface?
9. What is difference between Enumeration and Iterator interface?
10.What is difference between Stack and Queue?
11. What is difference between Comparable and Comparator interface?
12.How HashMap works in Java?
13.What are different Collection views provided by Map interface?
FAQ’s

Multithreading :
1. What is the difference between Process and Thread?
2. What are the benefits of multi-threaded programming?
3. What is difference between user Thread and daemon Thread?
4. How can we create a Thread in Java?
5. What are different states in lifecycle of Thread?
6. What is Thread Scheduler and Time Slicing?
7. What is context-switching in multi-threading?
8. How does thread communicate with each other?
9. Why thread communication methods wait(), notify() and notifyAll() are in Object class?
10. Why wait(), notify() and notifyAll() methods have to be called from synchronized method or
block?
11. Why Thread sleep() and yield() methods are static?
12. How can we achieve thread safety in Java?
13. What is Deadlock? How to analyze and avoid deadlock situation?
14. What is Java Timer Class? How to schedule a task to run after specific interval?
15. What is Thread Pool? How can we create Thread Pool in Java?
FAQ’s

Exception Handling :
1. What is Exception & Exception Handling in Java?
2. What are the Exception Handling Keywords in Java?
3. Explain Java Exception Hierarchy?
4. What are important methods of Java Exception Class?
5. What is difference between Checked and Unchecked Exception in Java?
6. What is difference between throw and throws keyword in Java?
7. How to write custom exception in Java?
8. What are different scenarios causing “Exception in thread main”?
9. What is difference between final, finally and finalize in Java?
10.What happens when exception is thrown by main method?
FAQ’s

Regular Expressions :
1. What is Regex ? Why we go for regex?
2. What are the classes in Java that helps to deal with regular expressions?
3. What is a metacharacter?
4. What are predefined character classes?
5. Which is regex engine class?
6. Which is compiler of regex?
7. What are advantages of regex?
FAQ’s

Annotations :
1. What are annotations? What are their typical use cases?
2. Describe some useful annotations from the standard library.
3. How can you create an annotation?
4. What object types can be returned from an annotation method declaration?
5. Which program elements can be annotated?
6. What are meta-annotations?
7. What are repeating annotations?
FAQ’s

Enum :
1. What is enum? Why we go for enum?
2. Can Enum implement interface in Java?
3. Can Enum extends class in Java?
4. Can we declare Constructor inside Enum?
5. Can we override toString() method for Enum? What happens if we don't?
6. How do you create Enum without any instance? Is it possible without compile time
error?
FAQ’s

Core java

More Related Content

What's hot

Similar to Core java

More from Mallikarjuna G D

Recently uploaded

Core java