ExceptionPropagation Hello4

package com; package com;

public class ExceptionPropagation { public class Hello4 {

public static void main(String[] args) { public String data;
m3(); int value;
} public final void processesData(int ab,String
static void m1(){ st){}
System.out.println("m1"); boolean isValied(){
throw new NullPointerException(); return false;
} }
static void m2(){ public class In1{}
m1(); class In2{}
System.out.println("m2"); }
} package com;
static void m3(){
m2(); public class Hai extends Hello4{
System.out.println("m3"); String name;
} public int id;
} protected double fee;
private long phone;
private Hai() {}
private Hai(int ab,String st) {}
Hai(int ab,long val,boolean b1) {}
public Hai(int ab,String st,boolean b1) {}
protected Hai(int ab,float ft,boolean b1) {}
void show(){}
public void display(int ab,String st){}
private int[] getValues(int ab,long val,boolean
b1){
return null;
}
class A{}
public class B{}
final class C{}
}
 Lab560 Lab561

public class Lab560 { public class Lab561 {

public static void main(String[] args) { public static void main(String[] args) {
System.out.println("Main start"); System.out.println("Stmt 0");
new Hello2().show("0"); try {
System.out.println("main comleted"); System.out.println("Stmt 1");
try {
} System.out.println("Stmt 2");
} catch (Exception e) {
} System.out.println("Stmt 3");
}finally{
class Hello2{ System.out.println("Stmt 4");
void show(String str){ }
System.out.println("show() called"); System.out.println("Stmt 5");
try{ } catch (Exception e) {
System.out.println("try block started: "); System.out.println("Stmt 6");
int a=Integer.parseInt(str); try {
int b=10/a; System.out.println("Stmt 7");
System.out.println("try block completed : "+b); } catch (Exception e2) {
System.out.println("Stmt 8");
} }finally{
catch(ArithmeticException e){ System.out.println("Stmt 9");
System.out.println("catch Block : "); }
System.exit(0); System.out.println("Stmt 10");
}finally{ }finally{
System.out.println("finaly block : "); System.out.println("Stmt 11");
try {
} System.out.println("Stmt 12");
} } catch (Exception e2) {
} System.out.println("Stmt 13");
}finally{
System.out.println("Stmt 14");
}
System.out.println("Stmt 15");
}
System.out.println("Stmt 16");
}
}
 Lab562 System.out.println("B->m2() begins");
new C().m3();
public class Lab562 { System.out.println("B->m2() ends");
}
public static void main(String[] args) { }
System.out.println("main() started"); class C{
try { void m3(){
new Hello3().show(); System.out.println("C->m3() begins");
} catch (Exception e) { int x=10/0;
System.out.println("\ncatch block"); System.out.println("C->m3() ends");
System.out.println("EX: "+e); }
System.out.println("Message : }
"+e.getMessage());
System.out.println("Cause : "+e.getCause());
System.out.println(); Lab563
e.printStackTrace();
} public class Lab563 {
System.out.println("Main() completed");
public static void main(String[] args) {
} System.out.println("..Main Started..");
int x=10/0;
} System.out.println("Main Completed");

class Hello3{ }
void show(){
System.out.println("show() begins"); }
new A().m1();
System.out.println("show() ends");
}
}

class A{
void m1(){
System.out.println("A->m1() begins");
new B().m2();
System.out.println("A->m1() ends");
}
}
class B{
void m2(){
 Lab564 Lab565

public class Lab565 {

public class Lab564 {
public static void main(String[] args) {
public static void main(String[] args) { try {
Exception ex1=new int res=10/0;
ClassNotFoundException(); } catch (NumberFormatException e) {
Exception ex2=new NullPointerException();
System.out.println(ex1 instanceof }
RuntimeException); }
System.out.println(ex2 instanceof }
RuntimeException);

Lab566 Lab567

public class Lab566 { public class Lab567 {

public static void main(String[] args) { public static void main(String[] args) {
// try { try {
// int res=10/0; //no statement
// } catch } catch (Exception e) {
(CloneNotSupportedException e) {
// }
// } }
}
}

}
 Lab568 }
}
public class Lab568 { class StudentNotFoundException extends
RuntimeException{
public static void main(String[] args) { StudentNotFoundException(String sid) {
System.out.println("main start"); super(sid);
String nm=""; }
try { }
StudentService serv=new StudentService();
//nm=serv.getNameBySid(null); Lab569
//
nm=serv.getNameBySid(""); public class Lab569 {
//
nm=serv.getNameBySid("jlc-088"); public static void main(String[] args) {
nm=serv.getNameBySid("jlc-099"); System.out.println("main started");
System.out.println("name :"+nm); try {
} catch (Exception e) { StudentService1 serv = new StudentService1();
e.printStackTrace(); serv.getNameBySid(null);
} } catch (Exception e) {
System.out.println("Main completed"); e.printStackTrace();
}
} }
}
}
class StudentService1{
class EmptySidException extends String getNameBySid(String sid){
RuntimeException{ if(sid==null||sid.isEmpty()||sid.equals("jlc-
099"))
} throw new StudentNotFoundException1(sid);
class StudentService{ else
String getNameBySid(String sid){ return "Srinivas";
if(sid==null) }
throw new NullPointerException(); }
else if(sid.isEmpty()) class StudentNotFoundException1 extends
throw new EmptySidException(); RuntimeException{
else if(sid.equals("jlc-099")) StudentNotFoundException1(String sid) {
return "Srinivas"; super(sid);
else }
throw new StudentNotFoundException(sid); }
 Lab570 Lab571

public class Lab570 { public class Lab571 {

public static void main(String[] args) { public static void main(String[] args) {
System.out.println("main started"); System.out.println("main");
try { try {
StudentService2 serv = new StudentService2(); StudentService3 st = new StudentService3();
serv.getNameBySid(null); st.getNameById("ee");
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
} }

} }

} }
class StudentService3{
class StudentService2{ String getNameById(String sid) throws
String getNameBySid(String sid){ StudentNotFound{
if(sid==null||sid.isEmpty()||sid.equals("jlc- if(sid==null||sid.isEmpty()||!sid.equals("jlc-
099")) 099")){
throw new StudentNotFoundException1(sid); throw new StudentNotFound(sid);
else }else{
return "Srinivas"; return "rahul";
} }
} }
class StudentNotFoundException2 extends }
RuntimeException{ class StudentNotFound extends Exception{
StudentNotFoundException2(String sid) {
super(sid); public StudentNotFound(String sid){
} super(sid);
} }
}
 Lab572 Lab573
package com;
public class Lab572 {
public class Lab573 {
public static void main(String[] args) { public static void main(String args[]){
Student stu[]=new Student[500]; System.out.println("Main started");
try { Thread th=Thread.currentThread();
for (int i = 0; i < stu.length; i++) { ThreadGroup tg=th.getThreadGroup();
stu[i]=new Student(); System.out.println(th.getId()+"\t"
System.out.println((i+1)+" object creation"); +th.getName()+"\t"+tg.getName());
} for(int i=0;i<args.length;i++){
} catch (Error e) { String st=args[i];
System.out.println("error Occured : "+ e); System.out.println(th.getId()+"\t"
} +th.getName()+"\t"+tg.getName()+"\t"+st);
System.out.println("\n after Handling"); }
Student st=new Student(); System.out.println("Main completed");
} }
} }

class Student{
long arr[]=new long[215833];
}
 Lab574 Lab575

package com;
package com;
public class Lab574 {
public class Lab575 {
public static void main(String[] args) {
// TODO Auto-generated method stub public static void main(String[] args) {
MyThread t1=new MyThread(); // TODO Auto-generated method stub
MyThread t2=new MyThread(); MyThread1 th=new MyThread1();
t1.start(); Thread t1=new Thread(th);
t2.start(); Thread t2=new Thread(th);
Thread t=Thread.currentThread(); t1.start();
for(int i=1;i<=10;i++){ t2.start();
System.out.println(t.getName()+"- value is"+i); Thread t=Thread.currentThread();
try { for(int i=1;i<=10;i++){
Thread.sleep(500); System.out.println(t.getName()+"- value is"+i);
} catch (Exception e) { try {
e.printStackTrace(); Thread.sleep(500);
} } catch (Exception e) {
} e.printStackTrace();
} }
}
} }
}
class MyThread extends Thread{
public void run(){ class MyThread1 implements Runnable{
Thread th=Thread.currentThread(); public void run(){
for(int i=1;i<=10;i++){ Thread th=Thread.currentThread();
System.out.println(th.getName()+"- value for(int i=1;i<=10;i++){
is"+i); System.out.println(th.getName()+"- value
try { is"+i);
Thread.sleep(500); try {
} catch (Exception e) { Thread.sleep(500);
e.printStackTrace(); } catch (Exception e) {
} e.printStackTrace();
} }
} }
} }
}
 Lab576 Lab577

package com;
package com;
public class Lab577 {
public class Lab576 {
public static void main(String[] args) {
public static void main(String[] args) { ThreadGroup tg=new ThreadGroup("Rahul");
// TODO Auto-generated method stub MyThread9 th1=new MyThread9();
ThreadGroup tg=new Thread th=new Thread(tg,th1,"roy");
ThreadGroup("WE"); th.start();
MyThread2 th1=new }
MyThread2(tg,"jlc-Thread"); }
MyThread2 th2=new
MyThread2(); class MyThread9 implements Runnable{
th1.start();
th2.start(); public void run(){
} Thread th=Thread.currentThread();
ThreadGroup tg=th.getThreadGroup();
} int pri=th.getPriority();
class MyThread2 extends Thread{ for(int i=0;i<5;i++){
MyThread2(ThreadGroup tg, System.out.println(i+"\t"+th.getName()+"\t"
String name){ +tg.getName()+"\t"+pri);
super(tg,name); }
} }
MyThread2() { }
// TODO Auto-generated constructor stub
}
public void run(){
ThreadGroup tg=getThreadGroup();
int pri=getPriority();
for(int i=0;i<5;i++){
System.out.println(i+"\t"+getName()+
"\t"+tg.getName()+"\t"+pri);
}
}
}
 Lab578 Lab579
package com;
package com;
public class Lab578 {
public class Lab579 {
public static void main(String[] args) {
MyThread10 th=new MyThread10(); public static void main(String[] args)
th.setPriority(2); throws Exception {
th.start(); // TODO Auto-generated method stub
MyThread3 th=new MyThread3();
} Thread t1=new Thread(th);
System.out.println(t1.getState());
} t1.start();
Thread.sleep(500);
class MyThread10 extends Thread{ System.out.println(t1.getState());
Thread.sleep(5000);
public void run(){ System.out.println(t1.getState());
ThreadGroup tg=getThreadGroup(); }
int pri=getPriority(); }
for(int i=0;i<5;i++){ class MyThread3 extends Thread{
System.out.println(i+"\t"+getName()+"\t" public void run(){
+tg.getName()+"\t"+pri); Thread th=Thread.currentThread();
} for(int i=1;i<=10;i++){
} System.out.println(th.getName()+
} "- value is:"+i+"\t"+th.getState());
try {
Thread.sleep(500);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
}
 Lab580 acc.withdraw(225);
if(acc.getBal()<0){
package com; System.out.println("Account is Overdrawn....");
class Account{ }
int bal=970; }
public void withdraw(int amt){ }
if(bal>=amt){ }
System.out.println(Thread.currentThread(). public class Lab580 {
getName()+" is going to withdraw...."+bal);
try { public static void main(String[] args) {
Thread.sleep(1200); // TODO Auto-generated method stub
} catch (Exception e) { Account acc=new Account();
// TODO: handle exception new AccountThread(acc);
} }
bal-=amt;
System.out.println(Thread.currentThread(). }
getName()+" is completed to
withdraw...."+bal);
} Lab581
else{
System.out.println("No Founds for "+ package com;
Thread.currentThread().getName());
} public class Lab581 {
}
public int getBal(){ public static void main(String[] args) {
return bal; // TODO Auto-generated method stub
} Hello h1=new Hello();
} Hello h2=new Hello();
MyThread4 th1=new MyThread4(h1);
class AccountThread implements Runnable{ MyThread4 th2=new MyThread4(h1);
Account acc=null; //MyThread4 th2=new MyThread4(h2);
AccountThread(Account acc) { th1.start();
this.acc=acc; th2.start();
Thread t1=new Thread(this,"A"); }
Thread t2=new Thread(this,"B"); }
t1.start(); class MyThread4 extends Thread{
t2.start(); Hello h=null;
}
public void run(){
for(int i=1;i<=5;i++){
MyThread4(Hello h) { th2.start();
// TODO Auto-generated constructor stub }
this.h=h;
} }
public void run(){
h.show(); class MyThread5 extends Thread{
} Hello1 h=null;
} MyThread5(Hello1 h) {
class Hello{ // TODO Auto-generated constructor stub
synchronized void show(){ this.h=h;
Thread th=Thread.currentThread(); }
for(int i=0;i<5;i++){ public void run(){
System.out.println(th.getName()+"- show: h.show();
"+i+"\t"+this); }
try { }
Thread.sleep(500); class Hello1{
} catch (Exception e) { void show(){
// TODO: handle exception Thread th=Thread.currentThread();
e.printStackTrace(); synchronized(this){
} for(int i=0;i<5;i++){
} System.out.println(th.getName()+"- show:
} "+i+"\t"+this);
} try {
Thread.sleep(500);
} catch (Exception e) {
Lab582 // TODO: handle exception
e.printStackTrace();
package com; }
}
public class Lab582 { }
}
public static void main(String[] args) { }
// TODO Auto-generated method stub
Hello1 h1=new Hello1();
Hello1 h2=new Hello1();
MyThread5 th1=new MyThread5(h1);
MyThread5 th2=new MyThread5(h1);
//MyThread4 th2=new MyThread4(h2);
th1.start();
 Lab583 } catch (Exception e) {
// TODO: handle exception
package com; e.printStackTrace();
}
public class Lab583 { }
}
public static void main(String[] args) { }
// TODO Auto-generated method stub
Hello2 h1=new Hello2(); Lab584
Hello2 h2=new Hello2();
MyThread6 th1=new MyThread6(h1);
MyThread6 th2=new MyThread6(h1); package com;
th1.start();
th2.start(); public class Lab584 {
}
public static void main(String[] args) {
} // TODO Auto-generated method stub
Hello3 h1=new Hello3();
class MyThread6 extends Thread{ Hello3 h2=new Hello3();
Hello2 h=null; MyThread7 th1=new MyThread7(h1);
MyThread6(Hello2 h) { MyThread7 th2=new MyThread7(h1);
this.h=h; //MyThread4 th2=new MyThread6(h2);
} th1.start();
public void run(){ th2.start();
h.show(); }
}
} }

class Hello2{ class MyThread7 extends Thread{

synchronized static void show(){ Hello3 h=null;
Thread th=Thread.currentThread(); MyThread7(Hello3 h) {
for(int i=0;i<5;i++){ // TODO Auto-generated constructor stub
System.out.println(th.getName()+"- show: "+i); this.h=h;
try { }
Thread.sleep(500); public void run(){
h.show();
}
}
class Hello3{ Hello4 h=null;
static void show(){ public MyThread8(Hello4 h) {
Thread th=Thread.currentThread(); this.h=h;
synchronized (Hello.class) { }
for(int i=0;i<5;i++){ @Override
System.out.println(th.getName()+"- show: "+i); public void run() {
try { h.show();
Thread.sleep(500); }
} catch (Exception e) { }
// TODO: handle exception
e.printStackTrace(); class Hello4{
} synchronized void show(){
} Thread th=Thread.currentThread();
} for(int i=0;i<5;i++){
} try {
} //wait(1000);
//Thread.sleep(1000);
Lab585 System.out.println(th.getName()+" -
show:"+i+"\t"+this);
package com; } catch (Exception e) {
// TODO: handle exception
public class Lab585 { e.printStackTrace();
}
public static void main(String[] args) { }
Hello4 h=new Hello4(); }
MyThread8 th=new MyThread8(h); }
MyThread8 th1=new MyThread8(h);
th.start(); Lab586
th1.start();
package com;
}
import java.util.ArrayList;
}
public class Lab586 {
class MyThread8 extends Thread{
public static void main(String[] args) {
Hello5 h=new Hello5();
MyThread11 th=new MyThread11(h);
MyThread11 th1=new MyThread11(h);
th.start(); Lab587
th1.start();

} package com;

} import java.util.ArrayList;

class MyThread11 extends Thread{ public class Lab587 {

Hello5 h=null;
public MyThread11(Hello5 h) { public static void main(String[] args) {
this.h=h; Hello6 h=new Hello6();
} MyThread12 th=new MyThread12(h);
@Override MyThread12 th1=new MyThread12(h);
public void run() { th.start();
h.show(); th1.start();
}
} }

class Hello5{ }
synchronized void show(){
ArrayList al=new ArrayList(); class MyThread12 extends Thread{
Thread th=Thread.currentThread(); Hello6 h=null;
for(int i=0;i<5;i++){ public MyThread12(Hello6 h) {
try { this.h=h;
//wait(1000); }
//al.wait(1000); @Override
//Thread.sleep(1000); public void run() {
System.out.println(th.getName()+ h.show();
" - show:"+i+"\t"+this); }
} catch (Exception e) { }
// TODO: handle exception
e.printStackTrace(); class Hello6{
} void show(){
} ArrayList al=new ArrayList();
} Thread th=Thread.currentThread();
} synchronized (al){
for(int i=0;i<5;i++){
try { }
//wait(1000); this.x=x;
al.wait(1000); System.out.println(x+" is pushed..");
//Thread.sleep(1000); System.out.println(flag+" end push "+x);
System.out.println(th.getName()+ flag=true;
" - show:"+i+"\t"+this); //System.out.println(flag+" end push "+x);
} catch (Exception e) { notify();
// TODO: handle exception }
e.printStackTrace();
} public synchronized int pop(){
} if(!flag){
} System.out.println(flag+" begin pop "+x);
} try {
} wait();
} catch (Exception e) {
Lab588 e.printStackTrace();
}
package com; }

public class Lab588 { System.out.println(x+" is poped");

public static void main(String[] args) { try {

Stack st=new Stack(); Thread.sleep(1000);
B obj1=new B(st, "B"); } catch (Exception e) {
C obj2=new C(st, "C"); e.printStackTrace();
} }
System.out.println(flag+" end pop "+x);
} flag=false;
class Stack{ //System.out.println(flag+" end pop "+x);
int x; notify();
boolean flag=false; return x;
public synchronized void push(int x){ }
if(flag){
System.out.println(flag+" begin push "+x); }
try{
wait(); class B implements Runnable{
}catch(Exception e){ Stack st=null;
e.printStackTrace(); B(Stack st,String name){
} this.st=st;
t1.start(); Thread t1=new Thread(this,"name");
} Lab589
@Override
public void run() {
int a=1; package com;
for (int i = 0; i < 7; i++) {
st.push(a++); public class Lab589 {
} public static void main(String[] args) {
Service scr=new Service();
} scr.start();
for (char ch = 'a'; ch <='j'; ch++) {
} System.out.println("main Running "+ch);
try {
class C implements Runnable{ Thread.sleep(500);
Stack st=null; } catch (Exception e) {
C(Stack st,String name){ e.printStackTrace();
this.st=st; }
Thread t1=new Thread(this,"name"); }
t1.start(); }
} }
@Override
public void run() { class Service extends Thread{
int a=1; @Override
for (int i = 0; i < 7; i++) { public void run() {
st.pop(); for (int i = 0; i < 10; i++) {
} System.out.println("Service Running "+ i);
if(i==5){
} int x=10/0;
}
} try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
 Lab590 Lab591

package com; package com;

public class Lab590 { public class Lab591 {

public static void main(String[] args) public static void main(String[] args)
throws Exception { throws Exception {
Greeting gre=new Greeting(); Thread th=new Thread();
gre.start(); MyThreads myth=new MyThreads();
gre.join(); myth.start();
for (char ch = 'a'; ch <='j'; ch++) { myth.join();
System.out.println("main Running "+ch); for (char ch = 'a'; ch <='j'; ch++) {
try { System.out.println(th.getName()+
Thread.sleep(500); " main Running "+ch+"\t"+th.isDaemon());
} catch (Exception e) { try {
e.printStackTrace(); Thread.sleep(500);
} } catch (Exception e) {
} e.printStackTrace();
} }
} }
}
class Greeting extends Thread{ }
@Override
public void run() { class MyThreads extends Thread{
for (int i = 0; i < 10; i++) { @Override
System.out.println("Service Running "+ i); public void run() {
if(i==5){ for (int i = 0; i < 10; i++) {
int x=10/0; System.out.println(getName() +
} " Service Running "+ i+ "\t"+isDaemon());
try { try {
Thread.sleep(500); Thread.sleep(500);
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
} }
} }
 Lab592

Lab593
package com;

public class Lab592 { package com;

public static void main(String[] args)
throws Exception { public class Lab593 {
Thread th=new Thread();
MyThreads1 myth=new MyThreads1(); public static void main(String[] args) {
myth.start(); Runnable r=new Runnable() {
//myth.join();
th.setDaemon(true); @Override
for (char ch = 'a'; ch <='l'; ch++) { public void run() {
System.out.println(th.getName()+ Thread th=Thread.currentThread();
" main Running "+ch+"\t"+th.isDaemon()); for (int i = 0; i < 10; i++) {
try { System.out.println(th.getName()+"\t"+i);
Thread.sleep(500); }
} catch (Exception e) { }
e.printStackTrace(); };
} Thread th1=new Thread(r);
} Thread th2=new Thread(r);
} th1.start();
} th2.start();
}
class MyThreads1 extends Thread{ }
@Override
public void run() {
for (int i = 0; i < 5; i++) {

System.out.println(getName() +
" Service Running "+ i+ "\t"+isDaemon());
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
 try {
Lab594 Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
package com; }
System.out.println(th.getName()+
import java.util.concurrent. "\t task completed");
ExecutorService; }
import java.util.concurrent. }
Executors; }

public class Lab594 { Lab606

public static void main(String[] args)
throws Exception {
MyThreads2 myth=new MyThreads2(); package List;
ExecutorService ser=Executors. import java.util.*;
newFixedThreadPool(3); public class Lab606 {
for (int i = 0; i<=10; i++) {
ser.execute(myth); public static void main(String[] args) {
try { // TODO Auto-generated method stub
Thread.sleep(500); List list=new ArrayList();
} catch (Exception e) { list.add("sri");list.add("nivas");
e.printStackTrace(); list.add("dande");
} System.out.println(list);
} list.add(1,"java");
} System.out.println(list);
} list.remove(2);
//System.out.println(list.remove(2));
class MyThreads2 implements System.out.println(list);
Runnable{ }

public void run() { }

Thread th=Thread.currentThread();
for (int i = 0; i < 5; i++) {
System.out.println(th.getName() +"\t"+ i);
 Lab607 System.out.println(list);
int x=list.indexOf("nivas");
package List; System.out.println(x);
import java.util.*; int y=list.lastIndexOf("nivas");
public class Lab607 { System.out.println(y);
}
public static void main(String[] args) { }
// TODO Auto-generated method stub
List list=new ArrayList(); Lab609
list.add("sri");
list.add("nivas");
list.add("dande"); package List;
System.out.println(list);
list.add(1,"java"); import java.util.*;
System.out.println(list);
Object obj=list.get(2); public class Lab609 {
System.out.println(obj); public static void main(String[] args) {
//Object obj2=list.set(1, "abc"); List list=new ArrayList();
//System.out.println(obj2); list.add("sri");
//System.out.println(list); list.add("nivas");
} list.add("dande");
list.add("java");
} list.add("nivas");
list.add("jdbc");
Lab608 //list.add(44);
//System.out.println(list);
List list2=list.subList(1, 3);
package List; System.out.println(list);
import java.util.*; System.out.println(list2);
public class Lab608 { }
public static void main(String[] args) { }
List list=new ArrayList();
list.add("sri");
list.add("nivas");
list.add("dande");
list.add("java");
list.add("nivas");
list.add("jdbc");
 Lab610 Enumeration enu=v.elements();
while(enu.hasMoreElements())
package List; System.out.println(enu.nextElement());
import java.util.*; }
public class Lab610 { }
public static void main(String[] args) {
Vector v=new Vector(); Lab613
Enumeration enu=v.elements();
System.out.println(enu.nextElement()); package List;
System.out.println("main completed"); import java.util.*;
} public class Lab613 {
} public static void main(String[] args) {
List list=new ArrayList();
Lab611 Iterator it=list.iterator();
System.out.println(it.next());
package List; System.out.println("main completed");
import java.util.*; }
public class Lab611 { }
public static void main(String[] args) {
Vector v=new Vector();
Enumeration enu=v.elements(); Lab614
if(enu.hasMoreElements())
System.out.println(enu.nextElement());
System.out.println("main compleled"); package List;
} import java.util.*;
} public class Lab614 {
public static void main(String[] args) {
Lab612 List list=new ArrayList();
Iterator it=list.iterator();
package List; if(it.hasNext())
import java.util.*; System.out.println(it.next());
public class Lab612 { System.out.println("main completed");
public static void main(String[] args) { }
Vector v=new Vector(); }
v.addElement("sri");
v.addElement("nivas");
v.addElement("dande");
v.addElement("sd");
 Lab615
Lab617

package List;
import java.util.*; package List;
public class Lab615 { import java.util.*;
public static void main(String[] args) { public class Lab617 {
List list=new ArrayList(); public static void main(String[] args) {
list.add("sri"); List list=new ArrayList();
list.add("nivas"); list.add("sri");
list.add("dande"); list.add("nivas");
Iterator it=list.iterator(); list.add("dande");
int size=list.size(); list.add("java");
//list.remove("sri"); list.add("jdbc");
for(int i=0;i<=size;i++) list.add("jsp");
System.out.println(it.next()); ListIterator lit=list.listIterator();
System.out.println("main completed"); while(lit.hasNext()){
} Object obj=lit.next();
} System.out.println(obj);
}
Lab616 }
}
package List;
import java.util.*; Lab618
public class Lab616 {
public static void main(String[] args) {
List list=new ArrayList(); package List;
list.add("sri");
list.add("nivas"); import java.util.*;
list.add("dande");
Iterator it=list.iterator(); public class Lab618 {
while(it.hasNext()){ public static void main(String[] args) {
Object obj=it.next(); List list=new ArrayList();
System.out.println(obj); list.add("sri");
} list.add("nivas");
} list.add("dande");
} list.add("java");
list.add("jdbc");
list.add("jsp");
ListIterator lit=list.listIterator();
System.out.println(list); Lab620
while(lit.hasNext()){
Object obj=lit.next();
System.out.println(obj); package List;
if(obj.equals("nivas")) lit.remove(); import java.util.*;
else if(obj.equals("java")) lit.set("core java"); public class Lab620 {
else if(obj.equals("jsp")) lit.add("serviets"); public static void main(String[] args) {
} List list=new ArrayList();
System.out.println(list); list.add("sri");
} list.add("nivas");
} list.add("dande");
list.add("java");
Lab619 list.add("jdbc");
package List; list.add("jsp");
import java.util.*; ListIterator lit=list.listIterator(2);
public class Lab619 { do{
public static void main(String[] args) { int index=lit.nextIndex();
List list=new ArrayList(); Object obj=lit.next();
list.add("sri"); System.out.println(index+"\t"+obj);
list.add("nivas"); }
list.add("dande"); while(lit.hasNext());
list.add("java"); System.out.println();
list.add("jdbc"); lit=list.listIterator(5);
list.add("jsp"); do{
ListIterator lit=list.listIterator(); int index=lit.previousIndex();
System.out.println("forward order"); Object obj=lit.previous();
while(lit.hasNext()){ System.out.println(index+"\t"+obj);
int index=lit.nextIndex(); }while(lit.hasPrevious());
Object obj=lit.next(); }
System.out.println(index+"\t"+obj); }
}
System.out.println("reverse order");
while(lit.hasPrevious()){
int index=lit.nextIndex();
Object obj=lit.previous();
System.out.println(index+"\t"+obj);
}
}
}
 Lab623
Lab621

package Set;
package Set; import java.util.*;
import java.util.*; public class Lab623 {
public class Lab621 { public static void main(String[] args) {
public static void main(String[] args) { TreeSet set=new TreeSet();
HashSet set=new HashSet(); set.add("sri");
set.add("sri"); set.add("nivas");
set.add("nivas"); set.add("dk");
set.add(99); set.add("manish");
set.add("dk"); System.out.println(set);
set.add("manish"); }
System.out.println(set); }
}
} Lab624

Lab622 package Set;

import java.util.*;
public class Lab624 {
package Set; public static void main(String[] args) {
import java.util.*; TreeSet set=new TreeSet();
public class Lab622 { set.add("sri");
public static void main(String[] args) { set.add("nivas");
LinkedHashSet set=new LinkedHashSet(); set.add(99);
set.add("sri"); set.add("dk");
set.add("nivas"); set.add("manish");
set.add(99); System.out.println(set);
set.add("dk"); }
set.add("manish"); }
//set.add("");
//set.add("sri");
System.out.println(set);
}
}
 Lab625 Lab627

package Set; package Set;

import java.util.*; import java.util.*;
public class Lab625 { public class Lab627 {
public static void main(String[] args) { public static void main(String[] args) {
LinkedHashSet set=new LinkedHashSet(); HashSet set=new HashSet();
set.add(new Long(65)); set.add(new Student1(99));
set.add(new Byte((byte)65)); set.add(new Student1(99));
set.add(new Integer(65)); set.add(new Student1(99));
set.add("A"); set.add(new Student1(99));
System.out.println(set); System.out.println(set);
} }
} }
class Student1{
Lab626 int sid;
Student1(int sid){
package Set; this.sid=sid;
import java.util.*; }
public class Lab626 {
public static void main(String[] args) { public boolean equals(Object obj) {
HashSet set=new HashSet(); System.out.println("***equals()***");
set.add(new Student(99)); if(obj instanceof Student1){
set.add(new Student(99)); Student1 st=(Student1)obj;
set.add(new Student(99)); return this.sid==st.sid;
set.add(new Student(99)); }
System.out.println(set); return false;
} }
}
class Student{ public int hashCode() {
int sid; System.out.println("***hasCode***");
Student(int sid){ return sid;
this.sid=sid; }
}
@Override public String toString() {
public String toString() { System.out.println("to string");
// TODO Auto-generated method stub return ""+sid;
return ""+sid; }
}
} }
 Lab628 ts.add(11);
package Set; ts.add(3);
import java.util.*; ts.add(9);
public class Lab628 { ts.add(4);
public static void main(String[] args) { ts.add(20);
TreeSet ts=new TreeSet(); System.out.println(ts);
ts.add(10); System.out.println("...subset()...");
ts.add(5); System.out.println(ts.subSet(4,11));
ts.add(7); System.out.println(ts.subSet(4,false,11,true));
ts.add(11); System.out.println(ts.subSet(4,true,11,true));
ts.add(3); System.out.println("...headset...");
ts.add(9); System.out.println(ts.headSet(9));
ts.add(4); System.out.println(ts.headSet(9,true));
ts.add(20); System.out.println(ts.headSet(2));
System.out.println(ts); System.out.println("...tailset...");
Set ts1=ts.descendingSet(); System.out.println(ts.tailSet(9));
System.out.println(ts1); System.out.println(ts.tailSet(9,false));
System.out.println("--ascending Iterator"); }
Iterator it=ts.iterator(); }
while(it.hasNext()) Lab630
System.out.println(it.next());
System.out.println("Descending Iterator");
Iterator it1=ts.descendingIterator(); package Set;
while(it1.hasNext()) import java.util.*;
System.out.println(it1.next()); public class Lab630 {
} public static void main(String[] args) {
} TreeSet ts=new TreeSet();
ts.add(10);
package Set; ts.add(5);
import java.lang.Character.Subset; ts.add(7);
import java.util.*; ts.add(11);
public class Lab629 { ts.add(3);
public static void main(String[] args) { ts.add(9);
TreeSet ts=new TreeSet(); ts.add(4);
ts.add(10); ts.add(20);
ts.add(5);
ts.add(7);
System.out.println("...pollfirst/last..."); Lab632
System.out.println(ts);
System.out.println(ts.pollFirst());
System.out.println(ts); package Set;
System.out.println(ts.pollLast()); import java.util.*;
System.out.println(ts); public class Lab632 {
System.out.println("...lower<..."); public static void main(String[] args) {
System.out.println(ts.lower(8)); TreeSet ts=new TreeSet();
System.out.println(ts.lower(3)); ts.add(new Employee());
System.out.println("...higher()>..."); ts.add(new Employee());
System.out.println(ts.higher(8)); ts.add(new Employee());
System.out.println(ts.higher(50)); ts.add(new Employee());
System.out.println(ts.higher(3)); }
System.out.println("...ceiling()>=..."); }
System.out.println(ts.ceiling(8));
System.out.println(ts.ceiling(12)); class Employee{
System.out.println("...floor()<=...");
System.out.println(ts.floor(8)); }
System.out.println(ts.floor(3));
} Lab633
}

Lab631 package Set;

import java.util.*;
package Set; public class Lab633 {
import java.util.*; public static void main(String[] args) {
public class Lab631 { TreeSet set=new TreeSet();
public static void main(String[] args) { set.add(new Student2(87,"sri"));
TreeSet ts=new TreeSet(); set.add(new Student2(99,"Dande"));
ts.add("sri"); set.add(new Student2(12,"Sd"));
ts.add("nivas"); set.add(new Student2(45,"nivas"));
ts.add("dande"); Iterator it=set.iterator();
ts.add("abhi"); while(it.hasNext()){
ts.add("rahul"); System.out.println(it.next());
} }
} }
}
class Student2 implements Comparable{ class Employee1 implements Comparable{
int sid; int eid;
String name; String name;
Student2(int sid,String name){ Employee1(int eid,String name){
this.sid=sid; this.eid=eid;
this.name=name; this.name=name;
} }
public int compareTo(Object obj) {
if(obj instanceof Student2){ public int compareTo(Object obj) {
Student2 st=(Student2) obj; if(obj instanceof Employee1){
return this.sid-st.sid; Employee1 em=(Employee1) obj;
} return this.name.compareTo(em.name);
return 0; }
} return 0;
public String toString() { }
// TODO Auto-generated method stub public String toString() {
return sid+"\t"+name; return eid+"\t"+name;
} }
} }

Lab634 Lab635

package Set; package Set;

import java.util.*; import java.util.TreeSet;

public class Lab634 {
public static void main(String[] args) { public class Lab635 {
TreeSet set=new TreeSet(); public static void main(String[] args) {
set.add(new Employee1(87,"sri")); TreeSet ts=new TreeSet();
set.add(new Employee1(99,"dande")); ts.add(new Student3());
set.add(new Employee1(12,"sd")); }
set.add(new Employee1(45,"nivas")); }
Iterator it=set.iterator();
while(it.hasNext()){ class Student3{
System.out.println(it.next());
} }
}
}
 Lab639 Lab641

package Map;
package Set;
import java.util.LinkedHashMap;
public class Lab639 { import java.util.Map;
public static void main(String[] args) {
int i=2; public class Lab641 {
i++; public static void main(String[] args) {
Map map=new LinkedHashMap();
//int sum=0; map.put("eid", new Integer(99));
//sum=i+2; map.put("name", "srinivas");
//sum=sum+2; map.put("phone", new
System.out.println(i); Long(65799999l));
} map.put("valid", new
} Boolean(true));
System.out.println(map);
Lab640 System.out.println(map.
containsKey("eid"));
package Map; System.out.println(map.
import java.util.LinkedHashMap; containsKey("email"));
import java.util.Map; System.out.println(map.
public class Lab640 { containsValue("srinivas"));
public static void main(String[] args) { System.out.println(map.
Map map=new LinkedHashMap(); containsValue(new Integer(99)));
System.out.println(map); System.out.println(map.
System.out.println("Size : "+map.size()); containsValue("sd"));
System.out.println("is empty :
"+map.isEmpty()); }
map.put("eid", new Integer(99));
map.put("name", "srinivas"); }
map.put("phone", new Long(65799999l));
map.put("valid", new Boolean(true));
System.out.println(map);
System.out.println("Size : "+map.size());
System.out.println("is empty :
"+map.isEmpty());
}
}
 Lab643 Lab645

package Map; package Map;

import java.util.Collection; import java.util.*;

import java.util.Iterator; import java.util.Map.Entry;
import java.util.LinkedHashMap;
import java.util.Map; public class Lab645 {
import java.util.Set; public static void main(String[] args) {
Map map=new HashMap();
public class Lab643 { map.put("eid", new Integer(99));
public static void main(String[] args) { map.put("name", "srinivas");
Map map=new LinkedHashMap(); map.put("phone", new Long(65799999l));
map.put("eid", new Integer(99)); System.out.println(map);
map.put("name", "srinivas"); Set set=map.entrySet();
map.put("phone", new Long(65799999l)); Iterator it=set.iterator();
System.out.println(map); while (it.hasNext()) {
Set set=map.keySet(); System.out.println(it.next());
System.out.println(set); }
Collection col=map.values();
System.out.println(col); }
Iterator it=set.iterator(); }
while (it.hasNext()) {
Object object = (Object) it.next();
System.out.println(object);
}
System.out.println(".........................");
Iterator it1=col.iterator();
while (it1.hasNext()) {
Object object = (Object) it1.next();
System.out.println(object);
}
}
}
 Lab646
map.put("nam", "roy");
map.put("phone", new Long(65799999l));
package Map; System.out.println(map);
Set set=map.entrySet();
import java.util.*; Iterator it=set.iterator();
import java.util.Map.Entry; while (it.hasNext()) {
System.out.println(it.next());
public class Lab646 { }
public static void main(String[] args) {
Map map=new LinkedHashMap(); }
map.put("eid", new Integer(99)); }
map.put("name", "srinivas");
map.put(88, "rahul"); Lab649
map.put("nam", "roy");
map.put("phone", new Long(65799999l));
System.out.println(map);
Set set=map.entrySet(); package generics;
Iterator it=set.iterator();
while (it.hasNext()) { import java.util.*;
System.out.println(it.next());
} public class Lab649 {
public static void main(String[] args) {
} System.out.println(".....use generics.....");
} List<String> list=new ArrayList<String>();
list.add("rahul");
Lab647 list.add("ranjan");
list.add("roy");
list.add("sonu");
package Map; list.add("rabi");
//list.add(33);
import java.util.*; System.out.println(list);
import java.util.Map.Entry; Iterator<String> it=list.iterator();
while (it.hasNext()) {
public class Lab647 { String string = (String) it.next();
public static void main(String[] args) { System.out.println(string);
Map map=new TreeMap<>(); }
map.put("eid", new Integer(99)); }
map.put("name", "srinivas"); }
map.put("nm", "rahul");
 Lab650
map.put(7,"roy");
map.put(3,"sonu");
package generics; map.put(5,"rabi");
//list.add(33);
import java.util.*; System.out.println(map);
Set<Entry<Integer, String>>
public class Lab650 { set=map.entrySet();
public static void main(String[] args) { Iterator<Entry<Integer, String>>
System.out.println(".....use generics....."); it=set.iterator();
Set<String> set=new HashSet<String>(); while (it.hasNext()) {
set.add("rahul"); Map.Entry<Integer, String> entry=it.next();
set.add("ranjan"); Integer i=entry.getKey();
set.add("roy"); String st=entry.getValue();
set.add("sonu"); System.out.println(i+"\t"+st);
set.add("rabi"); }
//list.add(33); }
System.out.println(set); }
Iterator<String> it=set.iterator();
while (it.hasNext()) { Lab652
String string = (String) it.next();
System.out.println(string); package generics;
}
} import java.util.*;
} public class Lab652 {
public static void main(String[] args) {
Lab651 System.out.println(".....use generics.....");
List<String> email=new ArrayList<String>();
package generics; email.add("rahul@123");
email.add("ranjan@12");
import java.util.*; email.add("roy@123");
import java.util.Map.Entry; email.add("sonu@123");
System.out.println(email);
public class Lab651 { List<Long> phone=new ArrayList<Long>();
public static void main(String[] args) { phone.add(1234l);
System.out.println(".....use generics....."); phone.add(3214l);
Map<Integer, String> map= phone.add(6547l);
new HashMap<Integer, String>(); phone.add(54323l);
map.put(2,"rahul"); System.out.println(phone);
map.put(3,"ranjan");
Map<String,Long> refs=new Lab653
LinkedHashMap<String, Long>();
refs.put("rahul", 32424l);
refs.put("ranjan", 45788l); package generics;
refs.put("roy", 45574l);
refs.put("sonu", 43564l); import java.util.*;
System.out.println(refs);
Student stu=new Student public class Lab653 {
(99, "rahul", email, phone, refs); public static void main(String[] args) {
ArrayList<Student> stu1=new ArrayList<Integer> intList=new
ArrayList<Student>(); ArrayList<Integer>();
stu1.add(stu); intList.add(123);
stu1.add(stu); intList.add(553);
stu1.add(stu); intList.add(853);
stu1.add(stu); show(intList);
System.out.println(stu1); System.out.println(".........................");
} ArrayList<Float> floatList=new
} ArrayList<Float>();
floatList.add(123.03f);
class Student{ floatList.add(553.05f);
int sid; floatList.add(853.01f);
String name; show(floatList);
List<String> email; System.out.println(".........................");
List<Long> phone; ArrayList<String> strList=new
Map<String,Long> refs; ArrayList<String>();
Student(int sid,String name,List strList.add("rahul");
<String> email,List<Long> strList.add("roy");
phone,Map<String,Long> refs){ strList.add("raj");
this.sid=sid; //show(strList);
this.name=name; }
this.email=email;
this.phone=phone; public static void show(List<? extends
this.refs=refs; Number> list){
} for (Number num: list) {
@Override System.out.println(num);
public String toString() { }
return sid+"\t"+name+"\t" }
+email+"\t"+phone+"\t"+refs; }
}
}
 Lab655 Lab657

package generics; package Queue;

import java.util.*; import java.util.*;

public class Lab655 { public class Lab657 {
public static void main(String[] args) { public static void main(String[] args) {
System.out.println(".....use generics....."); Queue<Stu1> st=new PriorityQueue<>();
Set<String> set=new HashSet<>(); st.add(new Stu1());
set.add("rahul"); st.add(new Stu1());
set.add("ranjan"); st.add(new Stu1());
set.add("roy"); System.out.println(st);
set.add("sonu"); }
set.add("rabi"); }
//set.add(33); class Stu1{}
System.out.println(set);
} Lab658
}
package Queue;
Lab656 import java.util.*;
public class Lab658 {
package generics; public static void main(String[] args) {
int value[]={1,4,2,8,7,3,5};
import java.util.*; Queue<Integer> st=new PriorityQueue<>();
public class Lab656 { for (Integer integer : value) {
public static void main(String[] args) { st.offer(integer);
System.out.println(".....use generics....."); }
Map<String,Long> refs=new System.out.println(st);
LinkedHashMap<>(); for (int i = 0; i < value.length; i++) {
refs.put("rahul", 32424l); System.out.println(st.poll());
refs.put("ranjan", 45788l); }
refs.put("roy", 45574l); System.out.println(st);
refs.put("sonu", 43564l);
System.out.println(refs); String
} str[]={"roy","rahul","ranjan","sonu","monu"};
} Queue<String> pt=new PriorityQueue<>();
for (String str1 : str) {
pt.offer(str1);
}
System.out.println(pt);
Lab660
for (int i = 0; i < str.length; i++) {
System.out.println(pt.poll());
} package Queue;
System.out.println(pt);
} import java.util.*;

} public class Lab660 {

public static void main(String[] args) {
Lab659 Queue<String> pt=new PriorityQueue<>();
pt.add("rahul");
pt.offer("rah");
package Queue; pt.add("ral");
pt.add("ran");
import java.util.*; pt.offer("raj");
System.out.println(pt);
public class Lab659 { System.out.println(pt.size());
public static void main(String[] args) { int le=pt.size();
Queue<String> pt=new PriorityQueue<>(); for (int i = 0; i < le; i++) {
pt.add("rahul"); System.out.println(pt.poll());
pt.add("rah"); }
pt.add("ral"); System.out.println(pt);
pt.add("ran"); System.out.println("*****************");
pt.add("raj"); Queue<String> pt1=new PriorityQueue<>();
System.out.println(pt); /*pt1.add("rah");
System.out.println("size "+pt.size()); pt1.add("rah1");
System.out.println("peek "+pt.peek()); pt1.add("rah6");
System.out.println("size "+pt.size()); pt1.add("rah2");
System.out.println("element "+pt.element()); pt1.add("rah4");
System.out.println("size"+pt.size()); pt1.add("rah5");
System.out.println("poll"+pt.poll()); pt1.add("rah3");
System.out.println("size"+pt.size()); pt1.add("rah8");*/
} pt1.offer("rah");
pt1.offer("rah1");
} pt1.offer("rah6");
pt1.offer("rah2");
 Lab661
pt1.offer("rah4");
pt1.offer("rah5");
pt1.offer("rah3"); package Collections;
pt1.offer("rah8");
System.out.println(pt1); import java.util.*;
System.out.println("***********
***************"); public class Lab661 {
Queue<String> str=new public static void main(String[] args) {
PriorityQueue<String>(10,new Psort()); List<String> list=new ArrayList<>();
str.offer("srinivash"); list.add("nivas");
str.offer("manish"); list.add("dande");
str.offer("kumar"); list.add("anand");
str.offer("bande"); list.add("kumar");
str.offer("ranjan"); System.out.println(list);
int len=str.size(); List<String> list2=new ArrayList<>();
System.out.println(str); list2.add("jsp");
for (int i = 0; i < len; i++) { list2.add("java");
System.out.println(str.poll()); list2.add("servlet");
} list2.add("jdbc");
} System.out.println(list2);
Collections.copy(list2, list);
} System.out.println("list : "+list2);
}
class Psort implements Comparator }
<String>{
Lab662
@Override
public int compare(String st1, package Collections;
String st2) {
return st1.compareTo(st2); import java.util.*;
}
public class Lab662 {
} public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("nivas");
list.add("dande");
list.add("anand");
list.add("kumar");
System.out.println(list);
Enumeration<String> Lab664
enu=Collections.enumeration(list);
while (enu.hasMoreElements()) { package Collections;
String string = (String) enu.nextElement();
System.out.println(string); import java.util.*;
}
public class Lab664 {
Vector<String> vc=new Vector<>(); public static void main(String[] args) {
vc.add("rahul"); List<String> list=new ArrayList<>();
vc.add("ranjan"); list.add("nivas");
vc.add("sonu"); list.add("dande");
System.out.println(vc); list.add("anand");
Enumeration<String> enm=vc.elements(); list.add("kumar");
List<String> info=Collections.list(enm); list.add("dande");
System.out.println(info); System.out.println(list);
} Collections.replaceAll(list, "dande", "jlc");
} System.out.println(list);
System.out.println("max :
Lab663 "+Collections.max(list));
System.out.println("min :
"+Collections.min(list));
package Collections; Collections.fill(list, "raj");
System.out.println(list);
import java.util.*; }
}
public class Lab663 {
public static void main(String[] args) {
Set s=Collections.singleton("jlc");
System.out.println(s);
s.add("hello");
System.out.println(s);
List lst=Collections.singletonList("jlc");
System.out.println(lst);
lst.add("hello");
System.out.println(lst);
}
}
 Lab665 Lab667

package Collections;
package Collections;
import java.util.*;
import java.util.*;
public class Lab665 {
public static void main(String[] args) { public class Lab667 {
List<String> list=new public static void main(String[] args) {
ArrayList<>(); List<StringBuilder> list=new ArrayList<>();
list.add("nivas"); list.add(new StringBuilder("nivas"));
list.add("dande"); list.add(new StringBuilder("dande"));
list.add(new StringBuilder("anand"));
list.add("anand"); list.add(new StringBuilder("kumar"));
list.add("kumar"); list.add(new StringBuilder("dande"));
list.add("dande"); System.out.println(list);
System.out.println(list); Collections.sort(list,new StringBuilderComp());
System.out.println("****** System.out.println(list);
**reverse***********"); }
Collections.reverse(list); }
System.out.println(list);
System.out.println("****** class StringBuilderComp implements
**rotate(2)***********"); Comparator{
Collections.rotate(list, 2);
System.out.println(list); @Override
System.out.println("****** public int compare(Object o1, Object o2) {
**rotate(-3)***********"); String st=o1.toString();
Collections.rotate(list, -3); String st2=o2.toString();
System.out.println(list); return st.compareTo(st2);
System.out.println("****** }
**shuffle***********");
for (int i = 0; i < list.size(); i++) { }
Collections.shuffle(list);
System.out.println(list);
}

}
}
 Lab669 Lab670

package Arrays; package Arrays;

import java.util.*; import java.util.*;

public class Lab669 { public class Lab670 {

public static void main(String[] args) { public static void main(String[] args) {
int arr[]={23,12,45,7,34,87,32}; int arr[]={23,12,45,7,34,87,32};
for (int i = 0; i < arr.length; i++) { for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); System.out.println(arr[i]);
} }
System.out.println("****** System.out.println("*****fill(arr,
sort*******"); 101)******");
Arrays.sort(arr); Arrays.fill(arr, 101);
for (int i = 0; i < arr.length; i++) { for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); System.out.println(arr[i]);
} }
System.out.println("****** Object []value=new Object[5];
binarySearch*******"); value[0]="sri";
int index=Arrays.binarySearch(arr, 47); value[1]=new Integer(123);
System.out.println(index); value[2]=new Boolean(true);
index=Arrays.binarySearch(arr, 45); //value[3]=new Integer(123);
System.out.println(index); value[4]=new Double(123.02);

int arr1[]={23,12,45,7,34,87,32}; List lst=Arrays.asList(value);

System.out.println("********* System.out.println(lst);
Arrays.equals(arr, arr1) }
*************"); }
System.out.println(Arrays.
equals(arr, arr1));
int arr2[]={23,12,45,7,34,87,32};
System.out.println("*********
Arrays.equals(arr1, arr2
)*************");
System.out.println(Arrays.
equals(arr1, arr2));
}
}
 Lab678 Lab679

package ResourceBundle;
package Locale;
import java.io.IOException;
import java.util.Locale; import java.util.*;

public class Lab678 { public class Lab679 {

public static void main(String[] args) { public static void main(String[] args)
Locale loc=Locale.getDefault(); throws IOException {
System.out.println(loc.getCountry()); String languageCode="en";
System.out.println(loc.getDisplayCountry()); System.out.println("H->Hindi , E->English");
System.out.println(loc.getLanguage()); System.out.println("enter your choise");
System.out.println(loc.getDisplayLanguage()); int asc=System.in.read();
Locale locs[]=Locale.getAvailableLocales(); char ch=(char) asc;
for (int i = 0; i < locs.length; i++) { ch=Character.toUpperCase(ch);
Locale L=locs[i]; if(ch=='H'){
System.out.println(L.getDisplayLanguage() languageCode="hi";
+"\t\t\t"+L.getDisplayCountry()); }else if (ch=='E') {
} languageCode="en";
}
} Locale loc=new Locale(languageCode);
ResourceBundle rsb=ResourceBundle.
} getBundle("messages", loc);
Enumeration ens=rsb.getKeys();
while (ens.hasMoreElements()) {
String key = (String)
ens.nextElement().toString();
String value=rsb.getString(key);
System.out.println(key+"\t\t"+value);

}
 Lab680 Lab681
package Timer; package Scanner;

import java.util.*; import java.util.Scanner;

public class Lab680 { public class LAb681 {

public static void main(String[] args) { public static void main(String[] args) {
System.out.println("About to schedule task"); Scanner scr=new Scanner(System.in);
new Reminder(5); System.out.println("binery");
System.out.println("task schedule task"); int bin=scr.nextInt(2);
} System.out.println(bin);

} }

class Reminder{ }
Timer time;
public Reminder(int sec) {
time=new Timer(); Lab682
time.schedule(new RemainderTask(),
sec*1000); package Scanner;
}
import java.util.Scanner;
class RemainderTask extends TimerTask{
public class LAb682 {
public void run() {
public static void main(String[] args) {
System.out.println("times up"); String str="Hi Myself rahul ranjan";
time.cancel(); Scanner scr=new Scanner(str);
} while (scr.hasNext()) {
String string = (String) scr.next();
} System.out.println(string);
} }

String str2="Hi Myself rahul ranjan.I am from

bihar.I have done BTech in cse from BPUT,
odisa.I have done 12th and 10th from
BSEB,patna";
Scanner scr2=new Scanner(str2); ft.format("my name is %s and age is %d ",
scr2.useDelimiter("\\."); str,age).toString();
while (scr2.hasNext()) { System.out.println(ft);
String string = (String) scr2.next(); ft.close();
System.out.println(string);
} Formatter ft2=new Formatter();
ft2.format("%c-%f-%b %n%05d-%o-%x-%X ",
} 'C',99.0,true,3456,3456,3456,3456).toString();
System.out.println(ft2);
} ft2.close();
}
Lab683 }

package Formatter;
Lab710
import java.util.Formatter;
package com;
public class Lab683 {
public static void main(String[] args) { public class Lab710 {
Formatter ft=new Formatter(); public static void main(String[] args) {
String str=ft.format("Sum of %d Direction d1=null;
and %d is %d", 10,20,(10+20)).toString(); //d1=new Direction("EAST", 0);
System.out.println(str); d1=Direction.EAST;
ft.close(); System.out.println(d1);
} System.out.println(Direction.WEST);
} System.out.println(Direction.SOUTH);
System.out.println(Direction.NORTH);
Lab684 System.out.println(d1.angle);
}
package Formatter; }

import java.util.Formatter; class Direction{

String name;
public class Lab684 { int angle;
public static void main(String[] args) { private Direction(String name,int angle){
Formatter ft=new Formatter(); this.name=name;
String str="srinivas"; this.angle=angle;
int age=23; }
static Direction EAST=new Direction("EAST",
0); enum Direction2 {
static Direction WEST=new EAST,WEST,SOUTH,NORTH;
Direction("WEST", 180); private Direction2() {
static Direction SOUTH=new System.out.println("df");
Direction("SOUTH", 270); }
static Direction NORTH=new static{
Direction("NORTH", 360); System.out.println("sb");
}
@Override }
public String toString() {
return name+"\t"+angle;
} Lab712

public int getAngle() {

return angle; package com;
}
public class Lab712 {
} public static void main(String[] args) {
Direction3 arr[]=Direction3.values();
Lab711 for (Direction3 d : arr) {
System.out.println("ordinal "+d.ordinal()+
package com; "name "+d.name());
}
public class Lab711{
public static void main(String[] args) { /*try {
Direction2 d1=null; Direction3 d = Direction3.valueOf("east");
//d1=new Direction2(); System.out.println(d);
d1=Direction2.EAST; } catch (Exception e) {
System.out.println(d1); e.printStackTrace();
System.out.println(Direction2.WEST); }*/
System.out.println(Direction2.SOUTH);
System.out.println(Direction2.NORTH); Direction3 d = Direction3.valueOf("EAST");
System.out.println(d);
} }
} }
enum Direction3{ enum Direction4{
EAST(0),WEST(180),SOUTH(270), EAST,WEST,SOUTH,NORTH;
NORTH(360); }
int angle;
private Direction3(int angle) {
this.angle=angle; Lab714
System.out.println("df"); package com;
}
static{ public class Lab714 {
System.out.println("sb");
} public static void main(String[] args) {
Direction5.EAST.show();
} Direction5.WEST.show();
Direction5.NORTH.show();
Lab713 Direction5.SOUTH.show();
package com;
}
public class Lab713 {
public static void main(String[] args) { }
Direction4 d=Direction4.EAST;
switch (d) { enum Direction5{
case EAST:
System.out.println("east"); EAST{
break; void show(){
case WEST: System.out.println("showing East Direction");
System.out.println("west"); }
break; },
case SOUTH: NORTH{
System.out.println("south"); void show(){
break; System.out.println("showing North Direction");
case NORTH: }
System.out.println("North"); },
break; WEST{
default: void show(){
break; System.out.println("showing West Direction");
} }
} },
}
 Test thread
SOUTH{
void show(){
System.out.println("showing South Direction"); package List;
} import java.util.ArrayList;
}; import java.util.Collection;
abstract void show(); import java.util.LinkedList;

} public class Test {

public static void main(String[] args) {
Collection col=new LinkedList();
Test col.add("rahul");
package Set; col.add(123);
col.add(true);
import java.util.HashSet; col.add("ranjan");
import java.util.Set; System.out.println(col);

public class Test { Collection col2=new ArrayList();

public static void main(String[] args) { col2.add(432);
Set st=new HashSet(); col2.add("raj");
st.add(new Stud(23)); col2.add("rahul");
st.add(new Stud(32)); col2.add("roy");
st.add(new Stud(15)); System.out.println(col2);
st.add(new Stud(40)); col.addAll(col2);
st.add(new Stud(15)); System.out.println(col);
System.out.println(st); //col.contains(col2);
} //System.out.println(col.containsAll(col2));
//System.out.println(col.removeAll(col2));
System.out.println(col.retainAll(col2));
System.out.println(col);
}
}
 Test

package List;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;

public class Test {

public static void main(String[] args) {
Collection col=new LinkedList();
col.add("rahul");
col.add(123);
col.add(true);
col.add("ranjan");
System.out.println(col);

Collection col2=new ArrayList();

col2.add(432);
col2.add("raj");
col2.add("rahul");
col2.add("roy");
System.out.println(col2);
col.addAll(col2);
System.out.println(col);
//col.contains(col2);
//System.out.println(col.containsAll(col2));
//System.out.println(col.removeAll(col2));
System.out.println(col.retainAll(col2));
System.out.println(col);
}
}