Core Java Material Updated 1
Core Java Material Updated 1
Java
Page No
1. INTRODUCTION OF JAVA .............................................................................................. 1
Platform independent
Open source
Multi-threading
More secure
portable
4. ENCAPSULATION ........................................................................................................... 7
5. INHERITANCE ................................................................................................................. 7
Single inheritance
Multilevel inheritance
Multiple inheritance
Hybrid inheritance
Hierarchical inheritance
9. LOOPING........................................................................................................................ 13
For
While
Do-while
1. Platform independent
2. Open source
3. Multithreading
4. More secure
5. Portable
1. Platform independent
During the compilation the java program converts into byte code
Using byte code we can run the application to any platform such as windows, mac, linux, etc
2. Open source:
A program in which source code is available to the general public for use and/or modification
from its original design at free of cost is called open source
3. Multithreading:
Java supports multithreading
It enables a program to perform several task simultaneously
4. More secure:
It provides the virtual firewall between the application and the computer
So it’s doesn't grant unauthorized access
5. Portable:
"Write once run anywhere"
Java code written in one machine can run on another machine
CORE JAVA
Syllabus:
1. Oops concept
2. Control statement/looping
3. Arrays
4. String
5. Exceptions
6. Collections
1. JDK
2. JRE
3. JVM
JDK:
JRE:
JVM:
Java Virtual Machine
It is mainly used to allocate the memory and compiling
TOOLS:
1. Notepad
2. Net bean
3. Eclipse
4. J Developer-oracle
5. RAD-IBM
Nowadays we mostly used eclipse (75% of the people using).
Versions of eclipse:
Juno
Kepler
Luna
Mars
Neon
OOPS CONCEPT:
Object Oriented Programing Structure
OOPS is a method of implementation in which programs are organized as collection of objects, class
and methods
1. Class
2. Method
3. Object
4. Abstraction
5. Encapsulation
6. Inheritance
7. Polymorphism
CLASS:
Syntax:
Public-Access specifier
METHOD:
Set of action to be performed
Camel notation: First word should be small after every word of the first letter should be capital
Syntax:
public void dummy() {
// Here dummy is a method name
}
Main Method:
public static void main(String[] args) {
Syntax:
Example program:
1. StudentDatabase
2.ECommerce
public class OnlineShoppingSite {
public void myAccount() { System.out.println("Account
Name");
}
Heap Memory:
ENCAPSULATION
Structure of creating folders
INHERITANCE:
We can access one class property into another class using 'extend' keyword and reusuable
purpose
2. Multilevel Inheritance
3. Multiple Inheritances
4. Hybrid Inheritance
5. Hierarchical Inheritance
One parent class is directly support into one child class using extend keyword
2. Multilevel Inheritance:
3. Multiple Inheritance:
More than one parent class parallely support into one child class but it won't suport in java
because
1. Priority problem
(i.e) if both parent class having same method name it will get priority problem so it doesn;t work in java
Parent class child class parent class
test () test()
test () is a method name, it present in both parent class, so its get priority problem
Class A
Class B Class C
Class D
5. Hierarchical Inheritance:
One parent class and more than one child class
Parent Class
ACCESS SPECIFIER:
1. Public
2. Protected
3. Default
4. Private
1. Public:
3. Default:
Ex,
4. Protected:
DATA TYPES:
-2^n-1 to +2^n-1 - 1
For byte,
1 byte =8 bits
So n=8
-128 to + 127
Ex:
public class ByteInfo {
public static void main(String[] args) { byte num=12;
System.out.println(num);
}
}
Long:
symbol 'l'
Float
Symbol-‘f’
float f=10.06f
Double:
No need to enter d
char:
Boolean:
java.lang
String:
WRAPPER CLASS:
Classes of data types is called wrapper class
It is used to convert any data type into object
All classes and wrapper classes default value is Null
CONTROL STATEMENT:
1. if
2. if.else
3. else.if
Example Program:
public class IfCondition {
public static void main(String[] args) {
int empID=20;
if(empID==20){
System.out.println("valid");
}else {
System.out.println("not valid");
}
}
}
1. logical &&,// logical && check first condition if its fail it doesn't check second
2.Bitwise &,/ bitwise & is check both condition
So logical && is better than bitwise
LOOPING:
1. for
2. while
3. do.while
For:
Example Program:
public class ForLoop {
public static void main(String[] args) {
System.out.println("Start");
for (int i = 1; i <= 3; i++) {
System.out.println(i);
}
System.out.println("End");
}
}
output:
Start
1
2
End
Example Program:
public class InnerForLoop {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 6; j++) {
System.out.print(i);
222222
333333
444444
555555
Println printline
Break:
It will exit from the current loop
Example Program:
public class InnerForLoop {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break;
}
System.out.println(i);
}
}}
Output:
Continue:
Example Program:
public class InnerForLoop {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i == 5) {
continue;
}
System.out.println(i);
10
Example Program:
public class InnerForLoop {
public static void main(String[] args) {
for (int i = 1; i <= 20; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
output
2
4
6
8
10
12
14
16
18
20
Example Program:
public class InnerForLoop {
public static void main(String[] args) {
for (int i = 1; i <= 20; i++) {
if (i % 2 == 1) {
System.out.println(i);
}
}
Output
1
3
5
7
9
11
13
15
17
19
Sum of odd:
Example Program:
public class SumofOddNum {
public static void main(String[] args) {
int count=0;
for(int i=1;i<=100;i++)
{
if(i%2==1){
count=count+i;
}
}
System.out.println(count);
}
}
2500
Sum of even:
Example Program:
public class SumofOddNum {
public static void main(String[] args) {
int count=0;
for(int i=1;i<=100;i++)
{
if(i%2==0){
count=count+i;
}
}
System.out.println(count);
}
}
Output:
2550
Factorial Numbers:
Example Program:
public class FactorialNumbers {
public static void main(String[] args) {
int count=1;
for(int i=1;i<=8;i++){
count=count*i;
}System.out.println(count);
}
}
Output:
40320
POLYMORPHISM:
Poly-many
Morphism-forms
Taking more than one forms is called polymorphism or one task completed by many ways
It has 2 types,
1.Method overloading(static binding/compile time polymorphism)
2.Method overriding(dynamic binding/run time polymorphism)
Class-same
Method-same
Argument-differ
In a same class method name is same and the argument is different is called method overloading
the argument is depends on
data types
data types count
data type order
Example Program:
public class StudentInfo {
private void studentId(int num) {
}
private void studentId(String name) { \\ depends on order
}
private void studentId(String email, int ph) { \\depends on data type
}
private void studentId(int dob, String add) { \\depends on datatype count
}
public static void main(String[] arg) { StudentInfo info =
new StudentInfo();
}
}
In the same method the argument can't use int and byte because int &byte both are numbers. so it
doesn't work.
public void employeeID(int num, byte num2) is not correct
2. Method overriding:
In a different class , the method name should be same and argument name should be same is
called overriding
Example Program:
output : ramya;
The same method name in both class it take sub class only
If we satisfied with super class we go for super class method but we won't satisfy with super class
we go for sub class method
We can assign our sub class to our super class but can't reverse
Example Program:
Marriage b=new Boy() is possible
Boy b=new Marriage() impossible
Inside the class if we use static we dont want to crate object (i.e)
public class Employee{ public static
void addNum(){
System.out.println("Hello");
}
public static void main(String[] args){
addNum(); // dont want to create object
}
}
Output: Hello
ABSTRACTION:
Example Program:
abstract class
super class
public class AxisBank extends Bank {
public void saving() { // method signature
System.out.println("saving regular");// business logic
}
public void current() { System.out.println("current");
}
public void salary() { System.out.println("salary");
}
public void joint() {
System.out.println("joint");
}
public static void main(String[] args) { AxisBank info
= new AxisBank();
chennai
salary
saving regular
2. INTERFACE/FULLY ABSTRACTION;
It will support only abstract method, won't support non abstract method
In interface "public abstract" is default. we no need to mention
It using implements keywords
Example Program:1
interface
public interface Bank { abstract
void saving(); abstract void
current(); abstract void salary();
abstract void joint();
public void branchDetails();
}
super class
public class AxisBank implements Bank {
public void saving() { System.out.println("saving
regular");
}
public void current() { System.out.println("current");
}
public void salary() { System.out.println("salary");
}
public void joint() {
System.out.println("joint");
}
public void branchDetails() { System.out.println("chennai");
}
public static void main(String[] args) { AxisBank info
= new AxisBank(); info.branchDetails();
info.salary();
info.saving();
}
}
multiple inheritance its won’t support in java but using interface its support
here we have to create 2 interface(super class) and one sub class(normal). In the sub class we
implement both interface
Example Program:2
interface
Abstract class:
It is partially abstraction
It support both abstract method and non-abstract method
It’s using "extends" keyword
Here "public abstract" have to mention
We can use whatever access specifier we want
Interface:
It is fully abstraction
It support only abstract method
It’s using "implement" keyword
"public Abstract" is default. no need to mention
Here we use only public( access specifier)
ARRAYS:
Here,
Example Program:
Output: 0
If we didn't assign any value, it will takes the default value of data types(int)
Default value of int is 0
Example Program:
public class BasicArray {
public static void main(String[] args) {
int num[]=new int[5];
num[0]=10;
num[1]=20;
num[2]=30;
num[3]=40;
num[4]=50;
System.out.println(num[2]);
}
}
Output: 30
}}
Output:
300
Output:
Output:
10
20
300
40
50
syntax:
for(int k:num)
System.out.println(k);
Example Program:
public class BasicArray {
public static void main(String[] args) {
int num[]=new int[5];
num[0]=10;
num[1]=20;
num[2]=30;
num[3]=40;
num[4]=50;
num[2]=300;
for(int k:num)
System.out.println(k);
}
}
Output:
10
20
300
40
50
In this enhanced for loop, have no condition checking and value assign
It is very fast compare to normal for loop
Advantage of array:
Disadvantage of arrays:
STRING:
Collections of charactor or word enclosed with double quotes
String function
Mutable string
Immutable string
Example Program:
public class StringBasic {
public static void main(String[] args) { String
s1="Vengat"; System.out.println(s1);
}
}
Output: Vengat
charAt():
Example Program:
public class StringBasic {
public static void main(String[] args) { String
s1="Vengat"; System.out.println(s1);
char ch = s1.charAt(2);
System.out.println(ch);
}
}
Output:
Vengat
n
2 takes as 0 to 2 (i.e) 0 1 2> v e n
Equqls():
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 =
"Vengat"; System.out.println(s1);
boolean b = s1.equals("Vengat");
System.out.println(b);
boolean b1 = s1.equals("vengat");
System.out.println(b1);}}
Equalsignorecase():
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 =
"Vengat"; System.out.println(s1);
boolean b = s1.equals("Vengat");
System.out.println(b);
boolean b1 = s1.equalsIgnoreCase("vengat");
System.out.println(b1);
}}
Output:
Vengat
true
true
contains():
Contains() is a method , is used to check the particular character or word in the string
Example Program:
public class StringBasic {
public static void main(String[] args) {
String s1 = "Hello welcome to java class";
System.out.println(s1);
boolean b = s1.contains("welcome");
System.out.println(b);
}
}
Output:
Output:
split():
split() is a method, is used to split the string by space or character or word or whatever
Example Program:
public class StringBasic {
public static void main(String[] args) {
String s1 = "Hello welcome to java class";
String[] x = s1.split(" "); // here we split by space
System.out.println(s1.length()); System.out.println(x.length);
String[] x1 = s1.split("o"); // here we split by "o"
System.out.println(s1.length()); System.out.println(x1.length);
}
}
Output:
27 //this whole string length s1
For loop:
Example Program:
public class StringBasic {
public static void main(String[] args) {
String s1 = "Hello welcome to java class";
Hello
welcome
to
java
class
Enhanced for loop:
public class StringBasic {
public static void main(String[] args) {
String s1 = "Hello welcome to java class";
String[] x = s1.split(" "); // here we split by space
for (String k : x) {
System.out.println(k);
}
}
}
Output:
Hello
welcome
to
java
class
toUpperCase() and toLowerCase():
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 =
"Hello";
String m = s1.toLowerCase(); // to convert lowercase
System.out.println(m);
String m1 = s1.toUpperCase(); // to convert upper
hello
HELLO
subString();
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 = "Hello
java";
String m = s1.substring(2);
System.out.println(m);
String m1 = s1.substring(2, 6);
// upto System.out.println(m1);
}}
Output:
llo java
llo
indexOf():
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 =
"Hello java";
int m = s1.indexOf("o"); // "o", to print o position
System.out.println(m);
int m1 = s1.indexOf("b"); // "b" is not in the string, so it print"-1" System.out.println(m1);
int m2 = s1.indexOf("a"); // multiple character "a", it takes firstone System.out.println(m2);
}
}
-1
lastIndexof():
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 =
"Hello java";
int m = s1.indexOf("o"); // "o", to print o position
System.out.println(m);
int m1 = s1.indexOf("b"); // "b" is not in the string, so it print"1" System.out.println(m1);
int m2 = s1.indexOf("a"); // multiple character "a", it takes firstone System.out.println(m2);
int m3 = s1.lastIndexOf("a"); // multiple character "a", it takes last
one
System.out.println(m3);
}
}
Output:
replace():
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 =
"Hello world";
String m = s1.replace("world", "java"); // to replace world to java System.out.println(m);
}
}
Output:
Hello java
Output:
isEmpty():
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 = "";
boolean m = s1.isEmpty();// here index is empty, so its true System.out.println(m);
String s2 = " ";
boolean m1 = s2.isEmpty();
// here index is not empty because space included System.out.println(m1); // space is also
a one character
}
}
Output:
true
false
startsWith() and endsWith():
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 =
"Hello java class"; boolean m =
s1.startsWith("Hello"); System.out.println(m);
boolean m1 = s1.endsWith("class");
System.out.println(m1);
}
}
Example Program:
public class Dummy {
public static void main(String[] args) {
char ch='M';
int x=ch; System.out.println(x);
}
}
Output: 77
compareTo():
Example Program:
public class Dummy {
public static void main(String[] args) { String s="A";
int i = s.compareTo("A");
System.out.println(i);
}
}
Output:
Example Program:
public class Dummy {
public static void main(String[] args) { String s="A";
int i = s.compareTo("B");
System.out.println(i);
}}
1
Here, 65-66=1
Example Program:
public class Dummy {
public static void main(String[] args) { String
s="ABCD";
int i = s.compareTo("ABFK ");
System.out.println(i);
}
}
Output:
3 // 6770=3
If it is different length and same accuration, the output will be based on length
Example Program:
public class Dummy {
public static void main(String[] args) { String
s="ABCD";
int i = s.compareTo("AB");
System.out.println(i);
}
}
Output:
Example Program:
public class Dummy {
public static void main(String[] args) { String
s="ABCD";
int i = s.compareTo("ACLK");
System.out.println(i);
}
}
1
Here, 6667=1, BC=1
Literal String:
It’s stored inside the heap memory (string pool or string constant).
It will share the memory if same value (duplicate value)
Non-literal string:
Example Program:
public class StringBasic {
public static void main(String[] args) { String s1 =
"vengat";
String s2 = "vengat"; // literal string(same value so its share
the memory)
System.out.println(System.identityHashCode(s1));
System.out.println(System.identityHashCode(s2)); String x1=new
String("vengat");
String x2=new String("vengat");// non literal string( its won't
share, create new memory
System.out.println(System.identityHashCode(x1)); System.out.println(System.identityHashCode(x2));
}
}
identityHashcode() is used to print the reference value(storage reference)
Output:
31168322 // literal string share the memory if same value
31168322
17225372
Immutable string:
Mutable string:
Output:
Immutable string
31168322
17225372
vengatprabu
17689166
vengatprabu
COLLECTIONS:
Why we go for collections:
1. List
2. Set
3. Map
1. List :( Interface)
ArrayList(class)
LinkedArrayList(c)
vector(c)
2.Set:(Interface)
Hashset(c)
Linked hashset(c)
Treeset(c)
3.Map:(Interface)
Hashmap(c)
Linked hashmap(c)
Treemap(c)
Hashtable(c)
concurrent hashmap(C)
List:
ArrayList:
Syntax:
Generics:
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex=new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(40);
ex.add(50); System.out.println(ex);
}
}
Output:
size():
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex=new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
}}
Output:
get():
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex=new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(40);
ex.add(50);
int x = ex.get(3); System.out.println(x);
}
}
Output:
40
For loop:
public class ArList {
public static void main(String[] args) { List<Integer> ex=new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(40);
ex.add(50);
for(int i=0;i<ex.size();i++){ System.out.println(ex.get(i));
}
}
}
10
20
30
40
40
50
Output:
10
20
30
40
40
50
Remove():
Example Program:
public class ArList {
public static void main(String[] args) {
Output:
[10, 20, 30, 40, 50]
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(40);
ex.add(50);
ex.add(2,100); System.out.println(ex);
}
}
Output:
[10, 20, 100, 30, 40, 40, 50]
In this o/p , if we insert one value based on index, after all the index value move to backward
set();
set is a method, it is used to replace the value but index and value order will not change
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>();
Output:
[10, 20, 100, 40, 40, 50]
contains():
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(40);
ex.add(50);
boolean x = ex.contains(30);
System.out.println(x); boolean y =
ex.contains(100);
System.out.println(y);
}
}
Output:
true
false
clear():
clear is a method it is used to clear the all index value
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
Output:
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(40);
ex.add(50);
int x = ex.indexOf(30);
System.out.println(x);
}
}
Output:
Lastindexof():
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(40);
Output:
addAll():
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>(); List<Integer> ex1 = new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(40);
ex.add(50); System.out.println(ex);
System.out.println(ex1);// before addAll
ex1.addAll(ex);
System.out.println(ex); System.out.println(ex1);//
After addAll
}
}
Output:
removeAll():
removeAll() is a method , it is used to compare the both list and remove all the list1 values in list
2
(i.e)
list2=list2-list1
Output:
If we go for removeAll method, here ex1.removeAll(ex), ex1 compare to ex and remove all ex
values in the ex1.
retainAll():
retainAll() is a method, it is used to compare both list and print the common values
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>(); List<Integer> ex1 = new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(50);
ex1.addAll(ex);
ex.add(100);
Output:
LinkedList:
systax:
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
LinkedList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(50); System.out.println(ex);
}
}
Output:
Vector:
syntax:
Example Program:
public class ArList {
public static void main(String[] args) {
Output:
Searching/retrieving is a worst
For ex, if we have 100 nodes, we have to print 90th node value, it will pass to all the previous
nodes and comes to first and then it will print.
It’s makes performance issue
Difference between ArrayList and Vector:
ArrayList:
Asynchronize
It is not a thread safe
Vector:
Synchronize
Thread safe
Class 1:
import java.util.ArrayList;
import java.util.List;
Class 2:
List:
Set:
Hashset:
Example Program:
public class ArList {
public static void main(String[] args) { Set<Integer> ex = new
HashSet<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(50);
ex.add(50); System.out.println(ex);
}
}
Output:
[50, 20, 40, 10, 30] // random order and ignore duplicate value
It will allows one Null value and won't allow duplicate NULL
LinkedHashset:
Insertion order
It will also allows one Null value and won't allow duplicate NULL
TreeSet:
Ascending order
Example Program:
public class ArList {
public static void main(String[] args) { Set<Integer> ex = new
TreeSet<Integer>(); ex.add(20);
ex.add(10);
ex.add(30);
ex.add(50);
ex.add(40);
ex.add(50); System.out.println(ex);
}
}
Output:
[10, 20, 30, 40, 50]
Example Program:
public class ArList {
public static void main(String[] args) { Set<String> ex = new
TreeSet<String>(); ex.add("Ramesh");
ex.add("babu");
ex.add("Vasu");
ex.add("10000"); System.out.println(ex);
}
}
(i.e)
1 ASCII value is 49
R ASCII value is 82
V ASCII value is 86
b ASCII value is 98
[49,82,86,98] [10000, Ramesh, Vasu, babu] this is a way to print ascending order.
Set:
It is not maintaining any order(i.e)
Hashset random order
LinkedHashset insertion order
Treeset ascending order
It is value based
remove():
remove is a method , it is used to remove particular value
public class ArList {
public static void main(String[] args) { Set<Integer> ex = new
TreeSet<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(50);
ex.add(50); ex.remove(40);
System.out.println(ex);
}
}
Output:
Normal for loop is not work here because it is not index based, it is value based
Output:
10
20
30
40
50
All wrapper class default value is Null as well as all class default value is Null
Null:
Null is a undefined/unknown/unassigned value
Null is won't create any memory
So Treeset will give exception in compile time if we use Null
Set:
we can copy the values from List to set as well as set to list
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex=new
ArrayList(); Set<Integer> ex1 = new TreeSet<Integer>();
ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(50);
ex.add(50);
ex.add(10); ex1.addAll(ex);
System.out.println(ex);
System.out.println(ex1);
}}
Output:
[10, 20, 30, 40, 50, 50, 10]
Example Program:
public class ArList {
public static void main(String[] args) { List<Integer> ex = new
ArrayList(); Set<Integer> ex1 = new TreeSet<Integer>();
ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40);
ex.add(50);
ex.add(50);
ex.add(10); ex1.addAll(ex);
System.out.println(ex);
System.out.println(ex1);
int i = ex.size() ex1.size();
System.out.println(i);
}
}
Map:
Hashmap:
Example Program:
public class ArList {
public static void main(String[] args) {
Map<Integer, String> ex = new HashMap<Integer,String>(); ex.put(10, "Java");
ex.put(20, "Java");
ex.put(30, "sql");
ex.put(40, ".net");
ex.put(50, "sales");
ex.put(50, "fire"); System.out.println(ex);
}
}
Output:
Linked Hashmap:
Hashtable:
Random order
Both key and values are ignore the Null
Map<Integer, String> ex = new Hashtable<Integer, String>()
concurrent hashmap:
Random order
Both key and values are ignore the Null
HashMap:
Hashtable:
Some Methods:
get():
Example Program:
public class ArList {
public static void main(String[] args) {
Map<Integer, String> ex = new HashMap<Integer,String>(); ex.put(10, "Java");
ex.put(20, "Java");
ex.put(30, "sql");
ex.put(40, ".net");
ex.put(50, "sales");
ex.put(50, "fire"); String
s=ex.get(40);
System.out.println(s);
}
}
.net
keyset():
Example Program:
public class ArList {
public static void main(String[] args) {
Map<Integer, String> ex = new HashMap<Integer,String>(); ex.put(10, "Java");
ex.put(20, "Java");
ex.put(30, "sql");
ex.put(40, ".net");
ex.put(50, "sales");
ex.put(50, "fire"); Set<Integer> s =
ex.keySet(); System.out.println(s);
}
}
Output:
Value():
Example Program:
public class ArList {
public static void main(String[] args) {
Map<Integer, String> ex = new HashMap<Integer,String>(); ex.put(10, "Java");
ex.put(20, "Java");
ex.put(30, "sql");
ex.put(40, ".net");
ex.put(50, "sales");
ex.put(50, "fire"); Collection<String> s =
ex.values(); System.out.println(s);
}
}
Output:
Example Program:
public class ArList {
public static void main(String[] args) {
Map<Integer, String> ex = new HashMap<Integer,String>(); ex.put(10, "Java");
ex.put(20, "Java");
ex.put(30, "sql");
ex.put(40, ".net");
ex.put(50, "sales");
ex.put(50, "fire");
Set<Entry<Integer, String>> s = ex.entrySet();
for(Entry<Integer, String> x:s){
System.out.println(x);
}
}
}
Output:
50=fire
20=Java
40=.net
10=Java
30=sql
We can print key and value seperately
Example Program:
public class ArList {
public static void main(String[] args) {
Map<Integer, String> ex = new HashMap<Integer,String>(); ex.put(10, "Java");
ex.put(20, "Java");
ex.put(30, "sql");
ex.put(40, ".net");
ex.put(50, "sales");
ex.put(50, "fire");
Set<Entry<Integer, String>> s = ex.entrySet();
for(Entry<Integer, String> x:s){
System.out.println(x.getKey());
System.out.println(x.getValue());
}
}
}
50
fire
20
Java
40
.net
10
Java
30
Sql
EXCEPTION:
Exception is like a error, the program will terminated that line itself
Example Program:
public class Exception {
public static void main(String[] args) {
System.out.println("Start");
System.out.println("1");
System.out.println("2");
System.out.println("3");
System.out.println(10/0);
System.out.println("4");
System.out.println("5");
System.out.println("End");
}
}
Output:
Start
1
2
Throwable:
Super class of exception throwable
Exception
Error
Exception:
Unchecked exception:
1. ArithmaticException
2. NullPointException
3. InputMismatchException
4. ArrayIndexOutOfBoundExcepion
5. StringIndexOutOfBoundExcepion
6. IndexOutOfBoundExcepion
7. NumberFormatException
Checked exception:
1. IOException
2. SQLException
3. FileNotFoundException
4. ClassNotFoundException
1. ArithmaticException:
If we are trying to give any number divided by zero, we get Arithmatic exception.
Example Program:
public class Exception {
public static void main(String[] args) {
System.out.println("Start");
Output:
Start
1
2
2. NullPointException:
If we give Null in the string, it will throw the Null point exception. Because default value of
string is Null.
Example Program:
public class Exception {
public static void main(String[] args) { String s= null;
System.out.println(s.length());
}
}
Output:
3. InputMismatchException:
If we getting input from the user, the user need to give integer input but the user trying to input
string value , at this this we get input mismatch exception
Output:
at java.util.Scanner.nextInt(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at org.exception.Exception.main(Exception.java:9)
4. ArrayIndexOutOfBoundExcepion:
In particular array, the index value is not available it will throw Array index of bound exception.
Example Program:
public class Exception {
public static void main(String[] args) { int
num[]=new int[4];
System.out.println(num[5]);
}
Output:
In particular String, the index value is not available it will throw String index Out of bound
exception.
Example Program:
public class Exception {
public static void main(String[] args) { String
s="Java";
char c = s.charAt(10);
System.out.println(c);
}
}
Output:
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 10
at java.lang.String.charAt(Unknown Source)
at org.exception.Exception.main(Exception.java:8)
6. IndexOutOfBoundExcepion:
In a list, the index value is not available it will throw index out of bound exception.
Example Program:
public class Exception {
public static void main(String[] args) { List<Integer> ex = new
ArrayList<Integer>(); ex.add(10);
ex.add(20);
ex.add(30);
ex.add(40); System.out.println(ex.get(3));
System.out.println(ex.get(10));
}
}
Output:
40
at org.exception.Exception.main(Exception.java:16)
if we give numbers in the string, we can convert the data type into integer. but if we give numand
char combination in the string, we can't convert to integer.
if we trying to convert, it will throw number format exception
Example Program:
public class Exception {
public static void main(String[] args) { String s="1234";
System.out.println(s+5);// string +5 int i =
Integer.parseInt(s); System.out.println(i+5);//
Integer +5
String s1="123Abc45"; int j =
Integer.parseInt(s1);
System.out.println(j+5);
}
}
Output:
12345
1239
Exception Handling:
1. Try
2. Catch
3. Finally
4. Throw
5. Throws
1. Network error
2. JVM crack
3. out of memory
4. stack overflow
If we get exception, try will throw the exception and catch will catch the exception
Example Program:
public class Exception {
public static void main(String[] args) {
System.out.println("start");
System.out.println("1");
System.out.println("2");
System.out.println("3");
try {
System.out.println(10/0);}
catch(ArithmeticException e){
System.out.println("dont/by zero");
}
System.out.println("4"); System.out.println("5");
System.out.println("end");
}
}
Output:
start
1
2
dont/by zero
4
5
end
Here we can enter the same exception or super class of the exception
Example Program:
we can use throwable
try {
System.out.println(10/0);}
catch(Throwable e){
System.out.println("dont/by zero");
}
instead of
try {
System.out.println(10/0);}
catch(ArithmeticException e){
System.out.println("dont/by zero");
Finally:
Example Program:
public class Exception {
public static void main(String[] args) {
System.out.println("start");
System.out.println("1");
System.out.println("2");
System.out.println("3");
try {
System.out.println(10/0);}
catch(ArithmeticException e){
System.out.println("dont/by zero");
}finally{
System.out.println("final");
}
System.out.println("4"); System.out.println("5");
System.out.println("end");}}
dont/by zero
final
4
end
Example program:
public class Exception {
public static void main(String[] args) {
System.out.println("start");
System.out.println("1");
System.out.println("2");
System.out.println("3");
try {
System.out.println(10/0);}
catch(NullPointerException e){
System.out.println("dont/by zero");
}finally{
System.out.println("final");
}
System.out.println("4"); System.out.println("5");
System.out.println("end");
}
}
Output:
start
1
2
final
Example Program:
public class Exception {
public static void main(String[] args) {
System.out.println("start");
System.out.println("1");
System.out.println("2");
System.out.println("3");
try {
System.out.println(10/0);}
catch(NullPointerException e){
System.out.println("null point");
}
catch(ArithmeticException e) {
System.out.println("dont/by zero");
}
finally{
System.out.println("final");
}
System.out.println("4"); System.out.println("5");
System.out.println("end");
}
}
Output:
start
1
2
dont/by zero
final
4
end
In a try block, one catch we can use same excepion and another catch we use throwable exception
if we give Super class and sub class combination, it will give compilation error
Example Program:
public class Exception {
public static void main(String[] args) {
System.out.println("start");
System.out.println("1");
System.out.println("2");
System.out.println("3");
try {
System.out.println(10/0);}
catch(NullPointerException e){
System.out.println("null point");
}
catch(Throwable e) {
System.out.println("dont/by zero");
}
finally{
System.out.println("final");
}
System.out.println("4"); System.out.println("5");
System.out.println("end");
}
}
Output:
start
1
2
dont/by zero
final
4
end
Example Program:
try {
System.out.println(10/0);}
catch(Throwable e) {
System.out.println("dont/by zero");
}
catch(NullPointerException e){
System.out.println("null point");
}
finally{
System.out.println("final");
}
If we give like above, will get compile time exception/error because we can't reverse
In one try block, we can write only one finally block
Inner try:
If we use inner try, it will print inner catch, inner finally and outerfinally.
But one try block handle one exception only, even if we use inner try also
If main try have no exception, it will through inner try. in that inner try if catch exception is
wrong, it will goes and print outer finally
Example Program:
public class Exception {
public static void main(String[] args) {
System.out.println("start");
System.out.println("1");
System.out.println("2");
System.out.println("3");
try {
System.out.println(10/0);
try {
String s=null; System.out.println(s.charAt(0));
}catch(NullPointerException e){
System.out.println("inner catch");
}finally{
System.out.println("inner finally");
}
Output:
start
1
2
dont/by zero
outer finaly
4
5
end
Example Program:
public class Exception {
public static void main(String[] args) {
System.out.println("start");
System.out.println("1");
System.out.println("2");
System.out.println("3");
try {
System.out.println(10/2);
try {
String s=null; System.out.println(s.charAt(0));
}catch(NullPointerException e){
System.out.println("inner catch");
}finally{
System.out.println("inner finally");
}
}
catch(ArithmeticException e) {
System.out.println("dont/by zero");
}
Output:
start
1
2
3
5
inner catch
inner finally
outer finaly
4
5
end
Throw:
Throws:
Example Program:
public class Exception {
public static void main(String[] args) throws InterruptedException, ArithmeticException,IOException{
info();
}
private static void info() throws IOException {
System.out.println("hello");
throw new IOException();
}
If we try to throws the compile time exception in any method, we must handle it in compile time
Constructor:
Class name and constructor name must be same.
It doesn’t have any return type.
We don’t want to call constructor which is creating object itself.
It will automatically invoke the default constructor.
It will support in method overloading but won’t support in method overriding
Example :
public class Const1 {
public Const1() {
System.out.println("i am in constructor");
}
public Const1(int a) {
System.out.println("1 argument int");
}
c.Const1(10);
}
}
Here,
Output:
i am in constructor
1 argument int
10
This:
It is a keyword.
If we use ‘this’ argument , we can pass without object
This argument we must use only in first statement
Example 1:
public class Const1 {
public Const1() {
this(10);
System.out.println("i am in constructor");
}
public Const1(int a){
System.out.println("1 argument int");
}
}
}
sOutput:
1 argument int
i am in constructor
}
public sample(int i) {
this(23.23f);
System.out.println("am integer constructor");
}
public sample(float f) {
System.out.println("am float constructor");
}
Output:
am float constructor
am integer constructor
i am in constructor
}
Output: 100
If same variable name in local level and class level, it will give first preference
is local level
}
public static void main(String[] args) {
sample s=new sample();
s.num();
}}
Output:
100
Method level access of this();
Output:
30
Final:
It’s a keyword.
If we use final before the variable, we can’t overwrite.
If we trying to overwrite it show compile time error.
As well as if we use final before the method/class, we can’t extend.
We can use final in three ways,
Variable level
Method level
Class level
Variable level using final:
We can overwrite the value of variable on variable declaration.
If we final, the value of variable can’t be overwrite.
Output:
output:
20 We get compile time error.
if we use final , we can’t overwrite
Method level using final():
Class 1:
public class sample {
public final void example() {
}
}
Class 2:
public class Const1 extends sample {
public void example(){ // we get compile time error here, because if we use final in
method level(parent class), we can't use again
}
}
Class level :
If we are using final in class level , we can’t extends to anywhere
CLASS:
Class is nothing but collection of methods or collection of objects.
METHOD:
A set of action to be performed
OBJECT:
Run time memory allocation
Using object we can call the any methods
We can access one class property into another class using 'extend' keyword is called
inheritance
Reusable purpose
It has 5 types
1. Single Inheritance
2. Multilevel Inheritance
3. Multiple Inheritance
4. Hybrid Inheritance
5. Hierarchical Inheritance
(i.e.) if both parent class having same method name it gets priority problem so it
doesn't work in java
During the compilation the java program converts into byte code
Using byte code we can run the application to any platform such as windows, mac,
Linux.Etc.
2. Open source:
A program in which source code is available to the general public for use and/or
modification from its original design at free of cost is called open source
3. Multithreading:
Java supports multithreading
It enables a program to perform several task simultaneously
4. More secure:
It provides the virtual firewall between the application and the computer
While:
Do. While:
Break:
Continue:
Poly many
Morphism forms
In a same class method name is same and the argument is different is called method
overloading
data types
data types count
data type order
In a different class , the method name should be same and argument name should be same is
called overriding
It has 2 types,
Abstract class:
It is partially abstraction
It support both abstract method and non-abstract method
Its using "extends" keyword
Here "public abstract" have to mention
We can use whatever access specifier we want
Interface:
It is fully abstraction
It support only abstract method
It’s using "implement" keyword
"Public Abstract" is default. no need to mention
Here only use public( access specifier)
java.lang
It has 2 types,
22. variable??
Long-8
1. Public
2. Protected
3. Default
4. Private
1. Public:
It is global level access( same package + different package)
2. Private:
It is a class level access
3. Default :
Package level access
4. Protected:
Inside package + outside Package( Extends)
we can access inside package and outside package using extend keyword
Poly-many
Morphism-forms
Taking more than one forms is called polymorphism.
One task is completed by many ways
It has 2 types,
1. Method overloading:
Data types
Data types count
Data type order
2. Method overriding:
In a different class , the method name should be same and argument name
should be same is called overriding
Hashtable:
29. What is the difference between linked list and array list?
ArrayList: Worst case
Immutable string:
We can store more duplicate value in same memory
We can't change the value in memory
In concord nation, we have to create new memory
Mutable string:
We can't store duplicate value in same memory
We can change the value in memory
In concord nation, its takes same memory
Non-thread safe:
a. Pascal notation
b. Camel notation
Camel notation :
1. Method name
2. Variable name
Set:
It is value based
ArrayList:
Asynchronies
It is not a thread safe
Vector:
Synchronize
Thread safe
Here,
It has 5 types
Hashmap(c)
Linked hashmap(c)
Treemap(c)
Hashtable(c)
Concurrent hashmap(C)
Throws:
Hashset:
Linked hashset:
Treeset:
Throwable
removeAll():
removeAll() is a method , it is used to compare the both list and remove all the list1 values in list
2
(i.e)
retainAll():
retainAll() is a method, it is used to compare both list and print the common values
Advantage of array:
Disadvantage of arrays:
49. What is the difference between normal class and abstract class
Abstract class:
It will support abstract method and non-abstract method
We won’t create object for abstract class
We won’t write any business logic in abstract method
Class:
It support only in non-abstract method
We can create object for class
1. A final class variable whose value cannot be 1. It’s a block of statement that definitely
changed. executes after the try catch block.
2. A final is declared as class level, they 2. If try block fails means, the final block will
cannot be inherited. executes once.
3. If final is declared as method level, they
cannot be override.
Output:
2500
}
}
System.out.println(count);
}
}
Output:
2550
Output:
50
}
}
System.out.println(count);
}
Output:
50
5. Factorial number:
public class FactorialNumbers {
Output:
40320
13
21
34
Output:
The numbers are
25
45
Output:
The numbers are
20
40
a = n;
while (a > 0) {
i = a % 10;
j = (j * 10) + i; a = a /
10;
}
System.out.println("Reverse number is=" + j);
int n, a, i = 0, j = 0;
Scanner an = new Scanner(System.in);
System.out.println("Enter a number"); n =
an.nextInt();
a = n;
while (a > 0) {
i = a % 10;
j = (j * 10) + i; a = a /
10;
}
if (n == j) {
System.out.println("palindrome");
} else {
System.out.println("Not palindrome Number");
}
}
}
Output:
Enter a number
141
palindrome
}
if (n == j) {
System.out.println(n);
}
}
}
Output:
1
11
22
33
44
55
66
77
88
99
}
if (n == j) {
c++;
}
System.out.println(c);
}
Output:
108
int n, a, i = 0, j = 0;
Scanner an = new Scanner(System.in);
System.out.println("Enter a number"); n =
an.nextInt();
a = n;
while (a > 0) {
i = a % 10;
j = j + (i * i * i); a = a / 10;
}
if (n == j) {
} else {
System.out.println("Not armstrong Number");
}
}
}
Output:
Enter a number
153
Armstrong number
}
if (n == j) {
System.out.println(n);
}
}}
Output:
1
153
370
371
407
}
if (n == j) {
c++;
}
}
System.out.println(c);
}
Output:
5
**
***
****
*****
Output:
*****
****
***
**
Output:
enter the number
17
prime
System.out.println(i);
}
}
}
}
System.out.println(c);
Output:
26
Output:
enter value:
67
C grade
enter value:
55
Fail
2*6=12
3*6=18
4*6=24
5*6=30
6*6=36
7*6=42
8*6=48
9*6=54
10*6=60
} else {
System.out.println("the biggest number is=" + d);
Output:
The four numbers are
23
45
56
22
String a = "welcome";
int vowels = 0;
int nonVowels = 0;
} else {
nonVowels++;
}
}
System.out.println(vowels);
System.out.println(nonVowels);
}
}
Output:
3
Output:
Enter no. of elements you want in array:6
Enter all the numbers:
10
20
100
40
200
60
Output:
20
100
40
200
60
Descending Order:200,100,60,40,20,10
}
}
}
for(int k=0;k<a.length;k++){
System.out.println(a[k]);
}
System.out.println("The Second minimum number is" + a[a.length-2]
);
Output:
64
45
24
-12
-23
-100
The Second minimum number is-23
}
}
}
for(int k=0;k<a.length;k++){
System.out.println(a[k]);
Output:
64
45
24
-12
-23
-100
The First maximum number is64
}
}
}
for(int k=0;k<a.length;k++){
System.out.println(a[k]);
}
System.out.println("The Third maximum number is" + a[a.length-4]
); }}
Output:
64
45
24
-12
-23
-100
The Third maximum number is24
package org.room.assign4;
count++;
} else if (s.charAt(i) >= 'A' && s.charAt(i) <= 'Z') {
count1++;
} else if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
count2++;
} else {
count3++;
}
}
System.out.println("total no of small letters:" + count); System.out.println("total no of
capital letters:" + count1); System.out.println("total no of digits :" + count2);
System.out.println("total no of special characters:" + count3);
}
}
Output:
total no of small letters:27 total no of
capital letters:7 total no of digits :3
total no of special characters:12
Output:
enter a no
5267546
no of digits present:7
package org.room.assign4;
import java.util.Scanner;
if (original.equals(reverse))
System.out.println("Entered string is a palindrome.");
else
System.out.println("Entered string is not a palindrome.");
Output:
Enter a string to reverse welcome
Reverse of entered string is: emoclew
package org.room.assign4;
Output:
Sum of Digits:15
emp.put(c, 1);
}
}
System.out.println(emp);
}
Output:
{vengat=1, ram=1}
char[] ch = s.toCharArray();
emp.put(c, 1);
}
}
System.out.println(emp);
}
}
}
Output:
39. Assume a string “welcome to Polaris” remove space and print the string.
public class Dummy {
public static void main(String[] args) {
String s="Welcome to Polaris";
String x = s.replace(" ", "");
System.out.println(x);
}
}
Output:
WelcometoPolaris
Output:
Enter a string to reverse
HELLO
Reverse of entered string is: OLLEH
Split:
public class StringBasic {
public static void main(String[] args) {
String s1 = "Hello welcome to java class";
String[] x = s1.split(" "); // here we split by space
for(int i=0;i<x.length;i++){
System.out.println(x[i]);
}
}
}
Output:
Hello
welcome
to
java
class
Program:
System.out.println();
rowCount++;
}
}
}
Output:
9
8 9 8
7 8 9 8 7
6 7 8 9 8 7 6
5 6 7 8 9 8 7 6 5
4 5 6 7 8 9 8 7 6 5 4
34 5 6 7 8 9 8 7 6 5 4 3
234 5 6 7 8 9 8 7 6 5 4 32
1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 21
42. Write a program to find sum of each digit in the given number using recursion?
Program:
int sum = 0;
if(number == 0){
return sum;
} else {
sum += (number%10);
getNumberSum(number/10);
}
return sum;
Output:
Sum is: 26
INPUT OUTPUT
java2novice = a2novice
java_language_is_sweet = uage_is
java_java_java_java = va_j, _jav
abcabcbb = bca, abc, cab
program:
return sb.toString();
}
Output :
[a2novice]
[uage_is]
[va_j, _jav]
[bca, abc, cab]
Program:
}
}
}
for(int k=0;k<a.length;k++){
System.out.println(a[k]);
}
System.out.println("The Third maximum number is :" + a[a.length-5] );
}
}
Output:
19
15
13
12
3
2
1
The Third maximum number is :13
int n, a, i = 0, j = 0;
Scanner an = new Scanner(System.in);
System.out.println("Enter a number");
n = an.nextInt();
a = n;
while (a > 0) {
i = a % 10;
j = j + (i * i * i);
a = a / 10;
}
if (n == j) {
System.out.println("Armstrong number");
} else {
System.out.println("Not armstrong Number");
}
}
}
Output :
Enter a number
371
Armstrong number
Program:
int j = 0;
int i = 1;
//return if the array length is less than 2
return output;
}
Output:
2 3 6 8 9 10 12
int start = 0;
int end = inputArr.length - 1;
while (start <= end) {
int mid = (start + end) / 2;
if (key == inputArr[mid]) {
return mid;
Output:
import java.util.ArrayList;
import java.util.Scanner;
}
}
5
4
3
2
1
0
9
8
7
6