Concepts and Code for U

Exception Handling in PL/SQL-1

2007-09-18T01:35:00.000-07:00

DECLARE
v_err_code number;
v_err_text varchar (255);
myexp Exception;
PRAGMA EXCEPTION_INIT(myexp,-2292);
N number:=10;
Y number:=0;
begin
if y=0
then
raise myexp;
else
N:=10/Y;
end if;
Exception
When myexp then
Y:=2;
N:=N/Y;
DBMS_output.put_line('zero divide exception error');
v_err_code:=SQLCODE;
v_err_text:=SQLERRM;
DBMS_output.put_line('value of N is after division is : ' || N);
DBMS_output.put_line('value of Y changed : ' || Y);
DBMS_OUTPUT.PUT_LINE(v_err_code || ' Description is ' ||v_err_text);
end;
/

DECLARE
v_err_code number;
v_err_text varchar (255);
myexp Exception;
PRAGMA EXCEPTION_INIT(myexp,-2292);
N number:=10;
Y number:=0;
begin
if y=0
then
raise myexp;
else
N:=10/Y;
end if;
Exception
When myexp then
RAISE_APPLICATION_ERROR (-20001, 'divide by zero------.');
Y:=2;
N:=N/Y;
DBMS_output.put_line('zero divide exception error');
v_err_code:=SQLCODE;
v_err_text:=SQLERRM;
DBMS_output.put_line('value of N is after division is : ' || N);
DBMS_output.put_line('value of Y changed : ' || Y);
DBMS_OUTPUT.PUT_LINE(v_err_code || ' Description is ' ||v_err_text);
end;

Exception Handling in PL/SQL

2007-09-18T01:34:00.002-07:00

DECLARE
MEMNAME EMP.ENAME%TYPE;
BEGIN
SELECT ENAME INTO MEMNAME FROM EMPKRIS
WHERE EMPNO = &INPUT_EMPNO;
DBMS_OUTPUT.PUT_LINE(MEMNAME);
EXCEPTION
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.PUT_LINE('No Such Employee');ed
END;
/
DECLARE
N number:=10;
Y number:=0;
i number;
begin
for i in -2..2
loop
y:=i;
begin
N:=10/y;
DBMS_output.put_line('value of N is after division is : ' || N);
Exception
When ZERO_Divide then
DBMS_output.put_line('value of Y is :: ' || Y || ' exception caught');
Y:=100;
N:=10/y;
DBMS_output.put_line('value of N is after division in exception block : ' || N);
end;
end loop;
end;

Looping in PL/SQL

2007-09-18T01:34:00.001-07:00

DECLARE
CURSOR emp_cur IS SELECT empno,sal,deptno
FROM empkris;
v_sal empkris.sal%TYPE;
v_empno empkris.empno%TYPE;
v_deptno empkris.deptno%TYPE;
v_ename empkris.ename%TYPE;
BEGIN
IF emp_cur%ISOPEN THEN
CLOSE emp_cur;
end if;
OPEN emp_cur;
LOOP
FETCH emp_cur INTO v_empno,v_sal,v_deptno;
EXIT when emp_cur%NOTFOUND;
DBMS_OUTPUT.PUT_LINE( 'Employee number is : ' || v_empno || ' his salary is :'|| v_sal || ' and he works in dept no :'|| v_deptno);
END LOOP;
CLOSE emp_cur;
END;
/

DECLARE
CURSOR emp_cur IS SELECT empno,sal,deptno
FROM empkris;
v_sal empkris.sal%TYPE;
v_empno empkris.empno%TYPE;
v_deptno empkris.deptno%TYPE;
v_ename empkris.ename%TYPE;
BEGIN
For c in emp_cur
LOOP
v_empno:=c.empno;
v_deptno:=c.deptno;
v_sal:=c.sal;
FETCH emp_cur INTO v_empno,v_sal,v_deptno;
DBMS_OUTPUT.PUT_LINE( 'Employee number is : ' || v_empno || ' his salary is :'|| v_sal || ' and he works in dept no :'|| v_deptno);
END LOOP;
END;
/

DECLARE
v_sal empkris.sal%TYPE;
v_empno empkris.empno%TYPE;
v_deptno empkris.deptno%TYPE;
v_ename empkris.ename%TYPE;
v_empnon empkris.empno%TYPE:=999;
CURSOR c_employee is select empno,deptno from empkris where empno=v_empnon;
BEGIN
OPEN c_employee;
LOOP
FETCH c_employee INTO v_empno,v_deptno;
EXIT WHEN c_employee%NOTFOUND;
DBMS_OUTPUT.PUT_LINE( 'Employee number is : ' || v_empno || ' and he works in dept no :'|| v_deptno);
END LOOP;
END;
/

Sample cursors in PL/SQL

2007-09-18T01:29:00.000-07:00

SQL Queries

2007-09-18T01:25:00.000-07:00

Query to retrive top 3 records:

select distinct (a.sal) from empkris a where 3 =(select count (distinct(b.sal)) from empkris bwhere a.sal<=b.sal);

Odd number of records:

select * from emp where (rowid,1) in (select rowid, mod(rownum,2) from emp);

Even number of records:

select * from emp where (rowid,0) in (select rowid, mod(rownum,2) from emp);

RandomAccessFiles in Java

2007-09-12T09:13:00.000-07:00

import java.io.File;
import java.io.RandomAccessFile;
import java.io.IOException;

public class RandomAccessFileExample {

private static void doAccess() {

try {

File file = new File("Test5Example.txt");

RandomAccessFile raf = new RandomAccessFile(file, "rw");

// Read a character

byte ch = raf.readByte();

System.out.println("Read first character of file: " + (char)ch);

System.out.println("Read full line: " + raf.readLine());

// Seek to the end of file

raf.seek(file.length());

// Append to the end of the file

raf.writeChars("for appending to the input file");

raf.writeBytes("this will also written into the output file");

raf.close();

}

catch (IOException e) {

System.out.println("IOException");

e.printStackTrace();

}

}

public static void main(String[] args) {

doAccess();

}

Program to read excel sheet Using Java program

2007-09-12T09:06:00.000-07:00

//program to read an excel sheet Using Java program

import java.io.*;
import java.util.*;
import java.sql.*;

public class TestExcel {

Connection c;
Statement stmnt;

public void Read_Excel()
{
try
{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

c = DriverManager.getConnection("jdbc:odbc:abc","",""); // abc is the DSN name
stmnt = c.createStatement();

String gh = "select * from [Offshore$]"; //Offshore being the name of the sheet in excel sheet

ResultSet rs = stmnt.executeQuery(gh);

while(rs.next())

{

System.out.println(rs.getString(1)+" "+rs.getString(2)+" "+rs.getString(3));// for displaying the three rows present in the excel sheet
}

}catch(Exception e)

{
System.out.println(""+e.toString());
}
finally

{
try

{
stmnt.close();
c.close();
}
catch( Exception e )
{
System.err.println( e );
}
}

public static void main(String[] args)
{
new TestExcel().Read_Excel();
}
}

Redirect output, error report to files instead of console

2007-08-07T11:04:00.000-07:00

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

/* Program to redirect output and error report to files instead of console */

import java.io.*;
class errorMessage
{
public static void main(String[] args)
{
try{
PrintStream st = new PrintStream(new FileOutputStream("error.txt"));
PrintStream ps = new PrintStream(new FileOutputStream("output.txt"));
System.setOut(ps);
System.setErr(st);
System.out.println("output redirected to file");
}catch(FileNotFoundException e){
System.out.println("exception caught");
}
System.out.println(args[2]);
}
}

Assertions in java

2007-05-28T09:10:00.001-07:00

An assertion has a Boolean expression that, if evaluated as false, indicates a bug in the code. This mechanism provides a way to detect when a program starts falling into an inconsistent state.Using assertions helps developers write code that is more correct, more readable, and easier to maintain.J2SE 1.3 and earlier versions have no built-in support for assertions. They can, however, be provided as an ad hoc solution.

import java.io.*;
public class AssertionExample {
public static void main(String argv[]) throws IOException {
System.out.print("Enter your marital status: ");
int c = System.in.read();
switch ((char) c) {
case 's':
case 'S': System.out.println("Single"); break;
case 'm':
case 'M': System.out.println("Married"); break;
case 'd':
case 'D': System.out.println("Divorced"); break;
default: assert !true : "Invalid Option"; break;
}
}
}

Make sure you use the -source option as follows:
prompt> javac -source 1.4 AssertionExample.java

If you now run the program using the command

prompt> java AssertionExample

and you enter a valid character, it will work fine. However, if you enter an invalid character, nothing will happen. This is because, by default,assertions are disabled at runtime. To enable assertions, use the switch -enableassertion (or -ea) as follows:

prompt> java -ea AssertionExample

Program to copy a folder in java

2006-06-19T10:04:00.000-07:00

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;
import java.lang.*;

public class Copy {

public static String copyFile(File inputFile,File outputFile){

String a="";
try{
FileReader in = new FileReader(inputFile);
FileWriter out = new FileWriter(outputFile);
int c;

while ((c = in.read()) != -1)
out.write(c);
in.close();
out.close();
}catch(Exception e){
}
return a;
}

public static void main(String[] args) throws IOException {
Copy obj = new Copy();
File inputFile = new File("your input directory which you want to replicate");
File outputFile = new File("target directory wher U want to place");
boolean success = (new File("target directory wher U want to place")).mkdir();
if (!success) {
System.out.println("Cannot create folder");
}
File dir = new File("your input directory which you want to replicate");

String[] children = dir.list();
if (children == null) {
// Either dir does not exist or is not a directory
} else {
for (int i=0; i<children.length; i++) {
// Get filename of file or directory
String filename = children[i];
}
}
for(int p=0;p<children.length;p++){
File f = new File(inputFile+"/"+children[p]);
File f1 = new File(outputFile+"/"+children[p]);
System.out.println(f+"==="+outputFile);

obj.copyFile(f,f1);
}

}

}

java.net.BindException: Address already in use: JVM_Bind:8080

2006-05-06T10:55:00.000-07:00

Both JBoss and Oracle RDBMS are using the port 8080. HTTP Server for JBoss, XDB listener for Oracle RDBMS.

So is the error "java.net.BindException: Address already in use: JVM_Bind:8080"

Way to over come is change the port of JBOSS change it to 8081 from 8080 in these two files given below so that you can avoid the error----- ;))

1) server.xml in
D:\jboss-3.2.6\server\all\deploy\jbossweb-tomcat50.sar

2) jboss-service.xml in
D:\jboss-3.2.6\server\all\deploy\http-invoker.sar\META-INF

java.lang.UnsupportedClassVersionError:

2006-04-23T07:16:00.000-07:00

java.lang.UnsupportedClassVersionError:

When I try to compile the simple Hello program there was no problem but when trying to compile it but its giving error when tyring to run the class file

class Hello
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
Exception in thread "main" java.lang.UnsupportedClassVersionError:
HelloWorld (Unsupported major.minor version 49.0)
at java.lang.ClassLoader.defineClass0(Native Method)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.access$100(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClassInternal(Unknown Source)

is the error I am getting.......

Solution:

Set the path using:

C:\oracle\ora92\bin;C:\Program Files\Oracle\jre\Change it to the latest version you have installed(1.5.0 in my case)\bin;

The error has occured becuase you have compiled the program with a latest version and trying to run it using a version which is older version.... so make it to a new version.

Merge Sort

2006-04-22T22:00:00.000-07:00


/*
 The merge sort splits the list to be sorted into two equal halves, and places them in 
 separate arrays. Each array is recursively sorted, and then merged back together to 
 form the final sorted list. Like most recursive sorts, the merge sort has an algorithmic 
 has an complexity of O(n log n).
 Elementary implementations of the merge sort make use of three arrays - one for each half 
 of the data set and one to store the sorted list in. The below algorithm merges the arrays
 in-place, so only two arrays are required. There are non-recursive versions of the merge sort, 
 but they don't yield any significant performance enhancement over the recursive algorithm on 
 most machines.


Pros: Marginally faster than the heap sort for larger sets.

Cons: At least twice the memory requirements of the other sorts; recursive.
 */

#include <stdlib.h>
#include <stdio.h>




void mergeSort(int numbers[], int temp[], int array_size);
void m_sort(int numbers[], int temp[], int left, int right);
void merge(int numbers[], int temp[], int left, int mid, int right);

int numbers[10];
int temp[10];


int main()
{
  int i;

  
  printf("Enter the numbers you want to sort");
  for(i=0;i<10;i++)
   scanf("%d",&numbers[i]);
  
  //perform merge sort on array
  mergeSort(numbers, temp, NUM_ITEMS);

  printf("Done with sort.\n");

  for (i = 0; i < NUM_ITEMS; i++)
    printf("%i\n", numbers[i]);
}


void mergeSort(int numbers[], int temp[], int array_size)
{
  m_sort(numbers, temp, 0, array_size - 1);
}



void m_sort(int numbers[], int temp[], int left, int right)
{
  int mid;

  if (right > left)
  {
    mid = (right + left) / 2;
    m_sort(numbers, temp, left, mid);
    m_sort(numbers, temp, mid+1, right);

    merge(numbers, temp, left, mid+1, right);
  }
}


void merge(int numbers[], int temp[], int left, int mid, int right)
{
  int i, left_end, num_elements, tmp_pos;

  left_end = mid - 1;
  tmp_pos = left;
  num_elements = right - left + 1;

  while ((left <= left_end) && (mid <= right))
  {
    if (numbers[left] <= numbers[mid])
    {
      temp[tmp_pos] = numbers[left];
      tmp_pos = tmp_pos + 1;
      left = left +1;
    }
    else
    {
      temp[tmp_pos] = numbers[mid];
      tmp_pos = tmp_pos + 1;
      mid = mid + 1;
    }
  }

  while (left <= left_end)
  {
    temp[tmp_pos] = numbers[left];
    left = left + 1;
    tmp_pos = tmp_pos + 1;
  }
  while (mid <= right)
  {
    temp[tmp_pos] = numbers[mid];
    mid = mid + 1;
    tmp_pos = tmp_pos + 1;
  }

  for (i=0; i <= num_elements; i++)
  {
    numbers[right] = temp[right];
    right = right - 1;
  }
}

Insertion Sort

2006-04-22T21:58:00.000-07:00

/** this is a program to implement Insertion sort
V.S.Phanindra
*/

/**
Algorithm Analysis
The insertion sort works just like its name suggests - it inserts each item into its proper place in the final
list. The simplest implementation of this requires two list structures - the source list and the list into
which sorted items are inserted. To save memory, most implementations use an in-place sort that works by
moving the current item past the already sorted items and repeatedly swapping it with the preceding item
until it is in place.
Like the bubble sort, the insertion sort has a complexity of O(n2). Although it has the same complexity,
the insertion sort is a little over twice as efficient as the bubble sort.

Pros: Relatively simple and easy to implement.
Cons: Inefficient for large lists.
*/
class InsertionSort
{
public static void main(String[] args)
{
int a[]={2,1,4,6,8,9,-1,4,3,10};
int temp,j;

for(int i=0;i<a.length;i++)
{
int index=a[i];
j=i;
while((j>0)&&(a[j-1]>index))
{
a[j]=a[j-1];
j=j-1;
}
a[j]=index;
}
for(int j1=0;j1<a.length;j1++)
System.out.println(a[j1]);
}

}

Selection Sort

2006-04-22T21:56:00.000-07:00

/**
The selection sort works by selecting the smallest unsorted item remaining in the list, and then swapping
it with the item in the next position to be filled. The selection sort has a complexity of O(n2).

It yields a 60% performance improvement over the bubble sort, but the insertion sort is over twice as fast as
the bubble sort and is just as easy to implement as the selection sort. In short, there really isn't any reason
to use the selection sort - use the insertion sort instead.

If you really want to use the selection sort for some reason, try to avoid sorting lists of more than a 1000 items
with it or repetitively sorting lists of more than a couple hundred items.

Pros: Simple and easy to implement.
Cons: Inefficient for large lists, so similar to the more efficient
insertion sort that the insertion sort should be used in its place.

*/
class SelectionSort
{
public static void main(String[] args)
{
int a[]={2,1,4,6,-1};
int j=0,temp=0;
for(int i=0;i<a.length-1;i++)
{
int min=i;
for(j=i+1;j<a.length;j++)
{
if(a[j]<a[min])
min=j;
}
temp=a[i];
a[i]=a[min];
a[min]=temp;
}
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
}

Program to Implement Quick Sort

2006-04-10T07:43:00.000-07:00

/**
The quick sort is an in-place, divide-and-conquer, massively recursive sort. The efficiency of the algorithm is majorly impacted by which element is choosen as the pivot point.The worst-case efficiency of the quick sort, O(n2), occurs when the list is sorted and the left-most element is chosen.*/

Pros: Extremely fast.
Cons: Very complex algorithm, massively recursive.

#include
#include

void quickSort(int numbers[], int array_size);
void q_sort(int numbers[], int left, int right);

int numbers[5];

int main()
{
int i;

printf("Enter the numbers to be sorted");
for (i = 0; i <5; i++)
scanf("%d",&numbers[i]);

//perform quick sort on array
quickSort(numbers, 5);

printf("List of Elements after Sorting.\n");
for (i = 0; i < 5; i++)
printf("%i\n", numbers[i]);
}

void quickSort(int numbers[], int array_size)
{
q_sort(numbers, 0, array_size - 1);
}

void q_sort(int numbers[], int left, int right)
{
int pivot, l_hold, r_hold;
static int count=0;
count++;
l_hold = left;
r_hold = right;
pivot = numbers[left];
while (left < right)
{
while ((numbers[right] >= pivot) && (left < right))
right--;
if (left != right)
{
numbers[left] = numbers[right];
left++;
}
while ((numbers[left] <= pivot) && (left < right))
left++;
if (left != right)
{
numbers[right] = numbers[left];
right--;
}
}
numbers[left] = pivot;
pivot = left;
left = l_hold;
right = r_hold;
if (left < pivot)
q_sort(numbers, left, pivot-1);
if (right > pivot)
q_sort(numbers, pivot+1, right);
}

Bubble Sort

2006-04-10T07:34:00.000-07:00

/** This is a program to implement bubble sort
Author : V.S.Phanindra
*/

The bubble sort is the oldest and simplest sort in use. Unfortunately, it's also the slowest, it sort works by comparing each item in the list with the item next to it, and swapping them if required.

Pros: Simplicity and ease of implementation.
Cons: Horribly inefficient.

class BubbleSort
{
public static void main(String[] args)
{
int a[]={2,1,4,6,8,9,-1,4,3,2};
int temp;

System.out.println("This is the List of elements before Sorting:");
for(int k=0;k<a.length;k++)
System.out.println(a[k]);
for(int i=0;i<a.length;i++)
{
for(int j=i+1;j<a.length-1;j++)
{
if (a[j] < a[i])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
} }
System.out.println("This is the sorted List of Elements:");
for(int j=0;j<a.length;j++)
System.out.println(a[j]);
}

}

Program for print Ramanjan Numbers

2006-04-08T12:07:00.000-07:00

/*Taking input as command line arguments and checks whether the numbers
form Ramanjan number.*/

/*Author:SivaPhanindra.Vemuri*/
#include
main(int argc,char *argv[])
{
int l,m,n,p;
if(argc!=5)
{
printf("Wrong Number of arguments\n");
exit(0);
}
l=atoi(argv[1]); //loading the values of l,m,n,p from the
// comman line arguments
m=atoi(argv[2]);
n=atoi(argv[3]);
p=atoi(argv[4]);
printf("%d\n%d\n%d\n%d\n",l,m,n,p);
if(l!=m!=p!=n)
{
if(cube(l)+cube(m)==cube(n)+cube(p))
printf("GIVEN NUMBERS FORM RAMANJAN SERIES\n");
else
printf("NUMBERS DOES'NT FORM RAMANJAN NUMBER\n");
}
else
printf("NUMBERS DOES'NT FORM RAMANJAN NUMBER\n");
}
int cube(int x) //defining cube
{
return(x*x*x);
}

Overriding in java

2006-04-06T21:47:00.000-07:00

when a method in a subclass has the same name and type signature as a method in its superclass, then the method in the subclass is said to override the method in the superclass. When an overridden method is called from within a subclass, it will always refer to the version of that method defined by the subclass.

sample program on overriding:

class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}

void show() {
System.out.println("i and j: " + i + " " + j);
}
}

class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}

void show() {
System.out.println("k: " + k);
}
}
class Override {
public static void main(String args[]) {
B subOb = new B(1, 2, 3);
subOb.show(); // this calls show() in B class
}
}

What if I want to call show method in super class.....

sample program on overriding:

class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}

void show() {
System.out.println("i and j: " + i + " " + j);
}
}

class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
void show() {
super.show(); // this calls A's show()
System.out.println("k: " + k);
}

What is overloading in java

2006-04-06T21:34:00.000-07:00

In Java it is possible to define two or more methods within the same class that share the same name, as long as their parameter declarations are different. When this is the case,the methods are said to be overloaded, and the process is referred to as method
overloading. Method overloading is one of the ways that Java implements polymorphism.

Sample program of overloading:

class Overloading {
void test() {
System.out.println("No parameters");
}

void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}

void test(float a) {
System.out.println("Inside test(double) a: " + a);
}
}
class Overload {
public static void main(String args[]) {
Overloading ob = new Overloading();
int i = 88;
ob.test();
ob.test(10, 20);
ob.test(i);
ob.test(123.2);
}
}

Program to reverse a string

2006-03-24T10:45:00.000-08:00

/*This is a program to reverse a given string that is taken from keyboard as input*/
#include<stdio.h>
#define length 20
main(){
int a[length];
int c=getchar();
int i=0,k=0;
while((c!='\n'))
{
a[i]=c;
i++;
c=getchar();
}
for(k=i-1;k>=0;k--)
printf("%c",a[k]);

}

XML Parser in Java

2006-03-14T04:58:00.000-08:00

// Team 1
// XML Parser

package book;
import java.io.File;
import org.w3c.dom.Document;
import org.w3c.dom.*;
import java.util.*;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

class XMLParser
{
public Hashtable getBooks()
{
Hashtable listBooks= new Hashtable();;
try
{
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
Document doc = docBuilder.parse (new File("e:/input.xml"));

// normalize text representation
doc.getDocumentElement ().normalize ();
NodeList totallistBooks = doc.getElementsByTagName("books");
int totalBooks = totallistBooks.getLength();

for(int s=0; s<totallistBooks.getLength() ; s++){

Node firstPersonNode = totallistBooks.item(s);
if(firstPersonNode.getNodeType() == Node.ELEMENT_NODE){

Element firstPersonElement = (Element)firstPersonNode;

//-------
NodeList firstNameList = firstPersonElement.getElementsByTagName("bookId");
Element firstNameElement = (Element)firstNameList.item(0);

NodeList textFNList = firstNameElement.getChildNodes();

NodeList lastNameList = firstPersonElement.getElementsByTagName("bookName");
Element lastNameElement = (Element)lastNameList.item(0);

NodeList textLNList = lastNameElement.getChildNodes();

//inserting into hashtable key value pairs

listBooks.put(((Node)textLNList.item(0)).getNodeValue().trim(),((Node)textFNList.item(0)).getNodeValue().trim());

}//end of if clause

}//end of for loop with s var

}
catch (SAXParseException err)
{
System.out.println ("** Parsing error" + ", line " + err.getLineNumber () + ", uri " + err.getSystemId ());
System.out.println(" " + err.getMessage ());

}
catch (SAXException e)
{
Exception x = e.getException ();
((x == null) ? e : x).printStackTrace ();

}
catch (Throwable t)
{
t.printStackTrace ();
}

return listBooks;
}
}

Algorithms Used in Garbage collection

2006-03-12T04:43:00.000-08:00

Post-HotSpot JVM:
The Exact VM (JVM 1.2.2) introduced exact garbage collection. Sun then improved the exact GC design in JVM 1.3 and renamed it generational GC. Java HotSpot VM 1.3.1's GC is fully accurate, guaranteeing that:

1)You can reliably reclaim all inaccessible objects' memory
2)You can relocate all objects to compact memory, eliminating object memory fragmentation

Three types of collection algorithms:
• Copy/scavenge collection
• Mark-compact collection
• Incremental (train) collection

The HotSpot JVM provides three GC algorithms, each tuned for a specific type of collection within a specific generation. The copy collection quickly cleans up short-lived objects in the new generation heap. The mark-compact algorithm employs a slower, more robust technique to collect longer-lived objects in the old generation heap. The incremental algorithm attempts to improve old generation collection by performing robust GC while minimizing pauses.

Copy/scavenge collection:
Using the copy algorithm, the JVM reclaims most objects in the new generation object space simply by making small scavenges . Longer-lived objects are ultimately copied, or tenured, into the old object space.

Mark-compact collection:
As more objects become tenured, the old object space begins to reach maximum occupancy. The mark-compact algorithm, used to collect objects in the old object space, has different requirements than the copy collection algorithm used in the new object space.

The mark-compact algorithm first scans all objects, marking all reachable objects. It then compacts all remaining gaps of dead objects. The mark-compact algorithm occupies more time than the copy collection algorithm; however, it requires less memory and eliminates memory fragmentation.

Incremental (train) collection:
The new generations copy/scavenge and the old generation mark-compact algorithms can't eliminate all JVM pauses. Such pauses are proportional to the number of live objects. To address the need for pause less GC, the Hotspot JVM also offers incremental, or train, collection.

Incremental collection breaks up old object collection pauses into many tiny pauses even with large object areas. Instead of just a new and an old generation, this algorithm has a middle generation comprising many small spaces. There is some overhead associated with incremental collection; you might see as much as a 10-percent speed degradation.

Lower Case to Uppre Case Conversion

2006-03-11T07:54:00.000-08:00

//PROGRAM FOR PRINTING CHARACTER IN UPPER CASE GIVEN THE CHARACTER IN LOWER CASE
//AUTHOR:SIVAPHANINDRA.VEMURI

import java.io.*; /*IMPORTING THE EXISTING CLASSES*/
class Task1d /*CLASS NAMED Task1d*/
{
public static void main(String[] args)throws IOException /*MAIN FUNCTION WHICH
THROWS AN IOEXCEPTION IF SATISFIES THE CONDITION*/
{
char c; //FOR STORING THE READ CHARCATER FROM THE USER
BufferedReader br=new BufferedReader (new InputStreamReader(System.in));/*BUFFERED READER FOR TAKING THE INPUT FROM THE USER*/
System.out.println("Enter Character To Quit Press 'q'");
do
{
c=(char)br.read(); /*READ FUNCTION TO READ CHARACTER WITH "br" AS AN OBJECT OF BEFFEREDREADER*/
if(c==10||c==13) /*TO ELIMINATE THE SPACE AND ENTER UNNECESSARY CHARACTERS*/
{}
else if(c=='q')
return;
else
System.out.println("UPPER CASE IS:"+(char)(c-32)); /*CONVERTING THE GIVEN CHARACTER INTO UPPER CASE*/
}while(c!='q'); /*REPEAT UNTIL GIVEN CHARACTER IS NOT EQUAL TO 'q'*/
}
}

PRINTING THE NON-PRIMES

2006-03-11T07:51:00.000-08:00

//PROGRAM FOR PRINTING THE NON-PRIMES INTO A FILE
//AUTHOR:SIVAPHANINDRA.VEMURI

import java.io.*; /*IMPORTING SECTION*/
class Task1e1 /* DECLARING A CLASS NAMED Task1e1*/
{
public static void main(String args[]) /*MAIN FUNCTION*/
{
FileOutputStream file_out=null; /* CREATING STREAMS FOR DIRECTING IT TO THE OUTPUT FILE*/
PrintStream pno=null;
try{
file_out=new FileOutputStream("non-primes.txt",false);
pno = new PrintStream(file_out,true);
}catch(FileNotFoundException e){ /* TO CATCH EXCEPTIONS */
System.out.println();
return;
}
catch(IOException e){
System.out.println("IOEXCEPTION");
return;
}
int num=2;
do
{
for(int i=2;i <num;i++)
{
if((num%i)==0) /*CHECKING FOR NON PRIMES*/
{

pno.println(num); /*FOR WRITING TO THE FILE */
pno.println();
break;
}
}
num++;
}while(num!=500); /*TO PRINT ALL THE NON PRIMES BETWEEN 1-500*/
}
}

PRIME FACTORS OF ALL NON-PRIMES BELOW 500

2006-03-11T07:49:00.000-08:00

/*TO PRINT THE PRIME FACTORS OF ALL NON-PRIMES BELOW 500*/
/*AUTHOR:SIVAPHANINDRA.VEMURI*/

import java.io.*; /*IMPORTING SECTION*/
class Task1e2 /* DECLARING A CLASS NAMED Task1e2*/
{
public static void main(String args[])throws IOException /*MAIN METHOD THROWING IOEXCEPTION*/
{
int i,j=0;
int a[]=new int [500]; /*ALLOCATING MEMORY FOR ARRAY A OF 500 SIZE*/
String fp; /* CREATING AN OBJECT FOR STRING*/
BufferedReader br=new BufferedReader (new FileReader("non-primes.txt"));
while((fp=br.readLine())!=null)
{
a[j]=Integer.parseInt(fp);
j++;
fp=br.readLine();
}
br.close();
PrintStream ps= new PrintStream(new FileOutputStream ("non-primes.txt"),true); /*CREATING AN OBJECT FOR PRINT STRAM*/
for(i=0;i {
ps.print(a[i]+":");
int prmfact = 2;
while (a[i] > 1)
{
if (a[i] % prmfact == 0)
{
ps.print(prmfact+"*"); /*PRINITING THE PRIMEFACTOR TO THE FILE*/
a[i] = a[i] / prmfact;
}
else
{
prmfact = prmfact + 1;
}
if (prmfact * prmfact > a[i])
{
ps.print(a[i]+" ");
ps.println();
break;
}
}
ps.println();
}

}
}

What is Garbage Collection & Why is Garbage Collection?

2006-03-10T05:42:00.000-08:00

The name garbage collection implies that objects no longer needed by the program are "garbage" and can be thrown away. When an object is no longer referenced by the program, the heap space it occupies can be recycled so that the space is made available for new objects. The garbage collector must somehow determine which objects are no longer referenced by the program and make available the heap space occupied by such unreferenced objects. In the process of freeing unreferenced objects, the garbage collector must run any finalizers of objects being freed.

In addition to freeing unreferenced objects, a garbage collector may also combat heap fragmentation. Heap fragmentation occurs through the course of normal program execution. New objects are allocated, and unreferenced objects are freed such that free portions of heap memory are left in between portions occupied by live objects. Requests to allocate new objects may have to be filled by extending the size of the heap even though there is enough total unused space in the existing heap. This will happen if there is not enough contiguous free heap space available into which the new object will fit.

Garbage collection relieves you from the burden of freeing allocated memory. Knowing when to explicitly free allocated memory can be very tricky. Giving this job to the Java virtual machine has several advantages. First, it can make you more productive. When programming in non-garbage-collected languages you can spend many hours on elusive memory problem. A second advantage of garbage collection is that it helps ensure program integrity. Garbage collection is an important part of Java's security strategy. Java programmers are unable to accidentally (or purposely) crash the Java virtual machine by incorrectly freeing memory.

A potential disadvantage of a garbage-collected heap is that it adds an overhead that can affect program performance. The Java virtual machine has to keep track of which objects are being referenced by the executing program, and finalize and free unreferenced objects on the fly. This activity will likely require more CPU time than would have been required if the program explicitly freed unnecessary memory. In addition, programmers in a garbage-collected environment have less control over the scheduling of CPU time devoted to freeing objects that are no longer needed.

Public static void main (String args[])

2006-03-10T05:04:00.000-08:00

The public keyword is an access specifier, which allows the programmer to control the visibility of class members. When a class member is preceded by public, then that member may be accessed by code outside the class in which it is declared.In this case, main( ) must be declared as public, since it must be called by code outside of its class when the program is started. The keyword static allows main( ) to be called without having to instantiate a particular instance of the class. This is necessary since main( ) is called by the Java interpreter before any objects are made. The keyword void simply tells the compiler that main( ) does not return a value. As you will see, methods may also return values.
As stated, main( ) is the method called when a Java application begins. Keep in mind that Java is case-sensitive. Thus, Main is different from main. It is important to understand that the Java compiler will compile classes that do not contain a main( ) method. But the Java interpreter has no way to run these classes. So, if you had typed Main instead of main, the compiler would still compile your program. However, the Java interpreter would report an error because it would be unable to find the main( ) method.
Any information that you need to pass to a method is received by variables specified within the set of parentheses that follow the name of the method. These variables are called parameters. If there are no parameters required for a given method, you still need to include the empty parentheses. In main( ), there is only one parameter, albeit a complicated one. String args[ ] declares a parameter named args, which is an array of instances of the class String. Objects of type String store character strings. In this case, args receives any command-line arguments present when the program is executed.

Delete and Update values in MySql Using Java

2006-03-09T10:44:00.000-08:00

/* A Sample program to Delete and Update values from and to a table Using Java*/

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

public class DeleteUpdate
{
public static void main(String args[]) {
try {
/* Test loading driver */

Hashtable members = new Hashtable();

// Load the JDBC driver
Class.forName("com.mysql.jdbc.Driver");

// Establish a connection
String url = "jdbc:mysql://localhost/test"; //here "test" is the name of the database in use
Connection connection = DriverManager.getConnection( url, "root", "kris" ); //root and password is name

/* Create a statement*/
Statement statement = connection.createStatement();

/*process to insert values into database test where phani is the tablename*/

String Delete = "delete from phani where name like '" + "Vemuri" + "'";
int j = statement.executeUpdate(Delete);

System.out.println("--------Values Deleted from table Successfully----------"+j);

/*process to Update values in your database test where phani is the tablename */

String Update = "update phani set name = '" + "aaaaaaa" +"' where ID = '" + "1000" +"'";
int updateCount = statement.executeUpdate(Update);

System.out.println("--------Values Updated Successfully----------"+ updateCount);

}
catch( Exception x ) {
x.printStackTrace();
}
}
}

/* Prerequisites you need to have Mysql installed in your system with a data base named "test"
and with username "root" and password "name"*/
/* Javac DeleteUpdate.java */
/* Java DeleteUpdate */

Insert values into table Using Java

2006-03-09T04:12:00.001-08:00

/* A Sample program to Insert values to a table Using Java*/

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

public class Insert
{
public static void main(String args[]) {
try {
/* Test loading driver */

Hashtable members = new Hashtable();

// Load the JDBC driver
Class.forName("com.mysql.jdbc.Driver");

// Establish a connection
String url = "jdbc:mysql://localhost/test"; //here "test" is the name of the database in use
Connection connection = DriverManager.getConnection( url, "root", "kris" ); //root and password is name

/* Create a statement*/
Statement statement = connection.createStatement();

/* Execute a statement for selecting values from database here details is the tables name in database "test"*/
String name[]={"Siva","Phanindra","Vemuri"};
String ID[]={"1000","9000","1232"};

/*process to insert values into database*/

for(int i=0;i<name.length;i++){
String INSERT = "insert into phani(name,ID)values ('" + name[i] + "','" +
ID[i] + "')";
int j = statement.executeUpdate(INSERT);
}

System.out.println("--------Values Inserted into table Successfully----------");

}
catch( Exception x ) {
x.printStackTrace();
}
}
}

/* Prerequisites you need to have Mysql installed in your system with a data base named "test"
and with username "root" and password "name"*/
/* Javac Insert.java */
/* Java Insert */

Program to Retrive values from Mysql Using Java

2006-03-08T01:41:00.000-08:00

/* A Sample program to connect to Mysql Using Java*/

import java.sql.*;

public class Test
{
public static void main(String args[]) {
try {
/* Test loading driver */

Hashtable members = new Hashtable();
String driver = "com.mysql.jdbc.Driver";
System.out.println( "----->loading driver:------->" );
Class.forName( driver );

/* Test the connection Here test is the name of the database you want to connect to*/
String url = "jdbc:mysql://localhost/test";

/*root is the user name and kris is the password of MYSql*/
DriverManager.getConnection( url, "root", "kris" );
System.out.println("connection established");

/* Create a statement*/
Statement statement = connection.createStatement();

/* Execute a statement for selecting values from database here details is the tables name in database "test"*/
ResultSet resultSet = statement.executeQuery("select * from details");
while (resultSet.next()){
members.put(resultSet.getString(1),resultSet.getString(2));
System.out.println(resultSet.getString(1) + "\t" +
resultSet.getString(2) );

}
catch( Exception x ) {
x.printStackTrace();
}
}
}

Java Mysql Connectivity

2006-03-07T02:57:00.002-08:00

Download mysql-connector-java-3.1.12.zip from www.mysql.com Extart the files and copy "mysql-connector-java-3.0.8-stable-bin.jar" and in C:\j2sdk1.4.2_04\jre\lib create a folder with name "java-mysql-connector" and place the jar file in it, next you need to set the Classpath You should also add the complete path to this JAR file in your CLASSPATH environment variable. In case if you don't know how to do that, go to Start -> Settings -> Control Panel -> System -> Advanced (tab) -> Environment Variables. Double-click 'CLASSPATH' if it is already listed there or click 'New' to create one with the name of 'CLASSPATH'. If you already had a 'CLASSPATH environment variable listed, simply type in (or paste) the complete path including file name in the window that opens up *at the end of* existing CLASSPATH values. If you are creating a new 'CLASSPATH' environment variable then simple enter '.;' and then append the complete path to Connector/J's JAR file.Note: The CLASSPATH variable contains a list of semi-colon separated folders and JAR files where JVM will search for Java class files. You should always separate paths with semi-colon (;) so that JVM can understand where one path ends and next one begins. Also keep in mind that in CLASSPATH variable paths, the first path is always '.' (single dot) which means current folder, so that JVM starts the search for Java class files from the current folder.

Program to Delete Files in a Given Directory

2006-03-06T04:37:00.000-08:00

import java.io.File;

/**
* Program to delete files in a directory.
*
* @author vsphanindra
*/

public class DeleteDirectory {

public static void function (File dir,String a){
String[] info = dir.list();
for (int i = 0; i < info.length; i++) {
File n = new File(a + dir.separator + info[i]);
if (!n.isFile())
continue;
System.out.println("Removed:" + n.getPath());
if (!n.delete())
System.err.println("Couldn't remove:" + n.getPath());
}
}
public static void main(String[] argv) {
if (argv.length != 1) {
System.err.println("Enter in this format :::-------- java Empty DeleteDirectory and its path ");
System.exit(1);
}

File dir = new File(argv[0]);
if (!dir.exists()) {
System.out.println(argv[0] + " Directory does not exist");
return;
}
function(dir,argv[0]);

}
}

/* javac DeleteDirectory.java */
/* java DeleteDirectory pathofthedirectory */

Program to Write to a file

2006-03-05T05:14:00.000-08:00

/* * FileOutputDemo * Using PrintStream classes * */

/* This program writes a given string to file named output.txt */
import java.io.*;
class FileOutputDemo
{
public static void main(String args[])
{
String a = "phanindra";
try {
FileOutputStream out = new FileOutputStream("output.txt");
PrintStream p = new PrintStream( out );
p.println (a);
p.close();
}
catch (Exception e) {
System.err.println ("Error writing to file");
}
}
}

Program to Rename Files in a given Directory

2006-03-04T10:47:00.000-08:00

import java.io.File;

/**
* Program to rename the files in a given Floder
*
* @author vsphanindra
*/
public class Rename {
public static void main(String[] argv) {
if (argv.length != 1) { // no progname in argv[0]
System.err.println("usage: Empty dirname");
System.exit(1);
}

File dir = new File(argv[0]);
if (!dir.exists()) {
System.out.println(argv[0] + " does not exist");
return;
}
String[] info = dir.list();
for (int i = 0; i < info.length; i++) {
File n = new File(argv[0] + dir.separator + info[i]);
/* this is the place where we will change the name of the file's
with the extension we wishin the given folder*/
String str= argv[0] + dir.separator+"Scene"+i+".jpg";
n.renameTo(new File(str));
}
}
}

/* javac Rename.java */

/*java Rename "absolute path of the directory which you want to change the file name in" */