AIM To develop a Java package with simple Stack and Queue classes. Use JavaDoc comments for documentation.

ALGORITHM

SOURCE CODE
//package com.st.joesph.demo.queue; /** * Array-based implementation of the queue. * @author Durai Murugan */ public class ArrayQueue { private Object [ ] theArray; private int currentSize; private int front; private int back; private static final int DEFAULT_CAPACITY = 10; /** * Construct the queue. */ public ArrayQueue( ) { theArray = new Object[ DEFAULT_CAPACITY ]; makeEmpty( ); } /** * Test if the queue is logically empty. * @return <b>true</b> if empty, <code>false</code> otherwise. */ public boolean isEmpty( ) { return currentSize == 0; } /** * Make the queue logically empty. */ public void makeEmpty( ) { currentSize = 0; front = 0; back = -1; } /** * Return and remove the least recently inserted item * from the queue. * @return the least recently inserted item in the queue. */ public Object dequeue( ) { if( isEmpty( ) ) throw new RuntimeException( "ArrayQueue dequeue" ); currentSize--; Object returnValue = theArray[ front ]; front = increment( front );

return returnValue; } /** * Get the least recently inserted item in the queue. * Does not alter the queue. * @return the least recently inserted item in the queue. */ public Object getFront( ) { if( isEmpty( ) ) throw new RuntimeException( "ArrayQueue getFront" ); return theArray[ front ]; } /** * Insert a new item into the queue. * @param x the item to insert. */ public void enqueue( Object x ) { if( currentSize == theArray.length ) doubleQueue( ); back = increment( back ); theArray[ back ] = x; currentSize++; } /** * Internal method to increment with wraparound. * @param x any index in theArray's range. * @return x+1, or 0 if x is at the end of theArray. */ private int increment( int x ) { if( ++x == theArray.length ) x = 0; return x; } /** * Internal method to expand theArray. */ private void doubleQueue( ) { Object [ ] newArray; newArray = new Object[ theArray.length * 2 ]; // Copy elements that are logically in the queue for( int i = 0; i < currentSize; i++, front = increment( front ) ) newArray[ i ] = theArray[ front ]; theArray = newArray; front = 0; back = currentSize - 1; }}

//package com.st.joesph.demo.queue;

/** * Array-based implementation of the stack. * @author Durai Murugan */ public class ArrayStack { private Object [ ] theArray; private int topOfStack; private static final int DEFAULT_CAPACITY = 10; /** * Construct the stack. */ public ArrayStack( ) { theArray = new Object[ DEFAULT_CAPACITY ]; topOfStack = -1; } /** * Test if the stack is logically empty. * @return true if empty, false otherwise. */ public boolean isEmpty( ) { return topOfStack == -1; } /** * Make the stack logically empty. */ public void makeEmpty( ) { topOfStack = -1; } /** * Get the most recently inserted item in the stack. * Does not alter the stack. * @return the most recently inserted item in the stack. */ public Object top( ) { if( isEmpty( ) ) throw new RuntimeException( "ArrayStack top" ); return theArray[ topOfStack ]; } /** * Remove the most recently inserted item from the stack. */ public void pop( ) { if( isEmpty( ) ) throw new RuntimeException( "ArrayStack pop" ); topOfStack--; } /**

* Return and remove the most recently inserted item * from the stack. * @return the most recently inserted item in the stack. */ public Object topAndPop( ) { if( isEmpty( ) ) throw new RuntimeException( "ArrayStack topAndPop" ); return theArray[ topOfStack-- ]; } /** * Insert a new item into the stack. * @param x the item to insert. */ public void push( Object x ) { if( topOfStack + 1 == theArray.length ) doubleArray( ); theArray[ ++topOfStack ] = x; } /** * Internal method to extend theArray. */ private void doubleArray( ) { Object [ ] newArray; newArray = new Object[ theArray.length * 2 ]; for( int i = 0; i < theArray.length; i++ ) newArray[ i ] = theArray[ i ]; theArray = newArray; }

//package com.st.joesph.demo.queue; public class QueueStackTester { public static void main(String[] args) { System.out.println("****************************"); System.out.println("Queue Example"); System.out.println("****************************"); ArrayQueue aq = new ArrayQueue(); aq.enqueue(new aq.enqueue(new aq.enqueue(new aq.enqueue(new String("1")); String("2")); String("3")); String("4")); Elements -> 1, 2, 3, 4"); FIFO -> "+aq.getFront()); removed element -> "+ FIFO -> "+aq.getFront());

System.out.println("Queue System.out.println("Queue System.out.println("Queue aq.dequeue()); System.out.println("Queue

System.out.println("****************************"); System.out.println("Stack Example"); System.out.println("****************************"); ArrayStack arrayStack = new ArrayStack(); arrayStack.push(new String("a")); arrayStack.push(new String("b")); arrayStack.push(new String("c")); arrayStack.push(new String("d")); System.out.println("Stack Elements -> a, b, c, d"); System.out.println("Stack LIFO -> "+arrayStack.top()); arrayStack.pop(); System.out.println("POP on Stack " ); System.out.println("Stack LIFO -> "+arrayStack.top());

} }

OUTPUT E:\User\Manikandan\Experiment 1>java QueueStackTester **************************** Queue Example **************************** Queue Elements -> 1, 2, 3, 4 Queue FIFO -> 1 Queue removed element -> 1 Queue FIFO -> 2 **************************** Stack Example **************************** Stack Elements -> a, b, c, d Stack LIFO -> d POP on Stack Stack LIFO -> c E:\User\Manikandan\Experiment 1>

AIM To design a class for Complex numbers in Java. In addition to methods for basic operations on complex numbers, provide a method to return the number of active objects created.

ALGORITHM

SOURCE CODE public class ComplexNumber { public static int counter = 0; private double realPart; private double imaginaryPart; /** * Default Constructor */ public ComplexNumber(){ counter++; } /** * Parameterized Constructor * @param realPart * @param imaginaryPart */ public ComplexNumber(double realPart, double imaginaryPart) { this(); this.realPart = realPart; this.imaginaryPart = imaginaryPart; } /** * Parameterized Constructor * @param realPart * @param imaginaryPart */ public ComplexNumber(ComplexNumber complexNumber) { this(); this.realPart = complexNumber.getRealPart(); this.imaginaryPart = complexNumber.getImaginaryPart(); } /** * @return the realPart */ public double getRealPart() { return realPart; } /** * @param realPart the realPart to set */ public void setRealPart(double realPart) { this.realPart = realPart; } /** * @return the imaginaryPart */ public double getImaginaryPart() {

return imaginaryPart; } /** * @param imaginaryPart the imaginaryPart to set */ public void setImaginaryPart(double imaginaryPart) { this.imaginaryPart = imaginaryPart; } public ComplexNumber getComplexConjugate(){ return new ComplexNumber(this.realPart, this.imaginaryPart * -1); } /** * @param multiComNum * @return */ public ComplexNumber multiplyTo(ComplexNumber multiComNum){ ComplexNumber result = new ComplexNumber(); //(a+bi)* (c+di) = (ac - bd) + (ad + bc) i double _real = ((this.realPart * multiComNum.getRealPart()) (this.imaginaryPart * multiComNum.getImaginaryPart())); double _imgry = ((this.realPart * multiComNum.getImaginaryPart()) + (this.imaginaryPart * multiComNum.getRealPart())); result.setRealPart(_real); result.setImaginaryPart(_imgry); return result; } /** * @param addComNum * @return */ public ComplexNumber addTo(ComplexNumber addComNum){ ComplexNumber result = new ComplexNumber(); //(a+bi) + (c+di) = (a+c) + (b+d) i double _real = (this.realPart + addComNum.getRealPart()); double _imgry = (this.imaginaryPart + addComNum.getImaginaryPart()); result.setRealPart(_real); result.setImaginaryPart(_imgry); return result; } /** * @param subsComNum * @return */ public ComplexNumber subsTo(ComplexNumber subsComNum){ ComplexNumber result = new ComplexNumber(); //(a+bi) - (c+di) = (a-c) + (b-d) i double _real = (this.realPart - subsComNum.getRealPart()); double _imgry = (this.imaginaryPart subsComNum.getImaginaryPart()); result.setRealPart(_real);

result.setImaginaryPart(_imgry); return result; } /** * @param divComNum * @return */ public ComplexNumber divTo(ComplexNumber divComNum){ ComplexNumber result = new ComplexNumber(divComNum); //(a+bi) / (c+di) = (a+bi)(c-di) / (c +di)(c - di) //numerator part result = result.multiplyTo(divComNum.getComplexConjugate()); //dr double dnr = divComNum.getRealPart() * divComNum.getRealPart() + divComNum.getImaginaryPart() * divComNum.getRealPart(); result.setRealPart(result.getRealPart() / dnr); result.setImaginaryPart(result.getImaginaryPart() / dnr); return result; } public String toString(){ String imgPart = ((this.imaginaryPart) < 0 ? String.valueOf(this.imaginaryPart) : "+"+this.imaginaryPart); return this.realPart+""+imgPart+"i"; } public static void main(String[] args) { System.out.println("************************************"); System.out.println("Complex Number Example"); System.out.println("************************************"); ComplexNumber complexNumber = new ComplexNumber(8, 4); ComplexNumber complexNumber2 = new ComplexNumber(1, 2); System.out.println("Complex Number = "+complexNumber); System.out.println(complexNumber +" ComplexConjugate = "+complexNumber.getComplexConjugate()); System.out.println("\nComplex Multiplication "); System.out.println("("+complexNumber+") ("+complexNumber2 +") = "+ complexNumber.multiplyTo(complexNumber2)); System.out.println("\nComplex Addition "); System.out.println("("+complexNumber+") + ("+complexNumber2 +") = "+ complexNumber.addTo(complexNumber2)); System.out.println("\nComplex Subraction "); System.out.println("("+complexNumber+") - ("+complexNumber2 +") = "+ complexNumber.subsTo(complexNumber2)); System.out.println("\nComplex Division "); System.out.println("("+complexNumber+") / ("+complexNumber2 +") = "+ complexNumber.divTo(complexNumber2)); System.out.println("\nThe number of active objects created during the basic complex number operations - "+ComplexNumber.counter); } }

OUTPUT E:\User\Manikandan\Experiment 2>java ComplexNumber ************************************ Complex Number Example ************************************ Complex Number = 8.0+4.0i 8.0+4.0i ComplexConjugate = 8.0-4.0i Complex Multiplication (8.0+4.0i) (1.0+2.0i) = 0.0+20.0i Complex Addition (8.0+4.0i) + (1.0+2.0i) = 9.0+6.0i Complex Subraction (8.0+4.0i) - (1.0+2.0i) = 7.0+2.0i Complex Division (8.0+4.0i) / (1.0+2.0i) = 1.6666666666666667+0.0i The number of active objects created during the basic complex number operations - 9 E:\User\Manikandan\Experiment 2> ------------------------------------------------------------------------------------------

AIM To design a Date class similar to the one provided in the java.util package. ALGORITHM

SOURCE CODE
import import import public java.util.Date; java.text.ParseException; java.text.SimpleDateFormat; class DateExample {

private static void DateExample() { Date date = new Date(); System.out.println("Current Date and Time is : " + date); System.out.println(); System.out.println("Date object showing specific date and time"); Date particulardate1 = new Date(24L*60L*60L*1000L); Date particulardate2 = new Date(0L); System.out.println(); System.out.println("First Particular date : " + particulardate1); System.out.println("Second Particular date: " + particulardate2); System.out.println(); System.out.println("Demo of getTime() method returning millisecon ds"); System.out.println(); Date strtime = new Date(); System.out.println("Start Time: " + strtime); Date endtime = new Date(); System.out.println("End Time is: " + endtime); long elapsed_time = endtime.getTime() - strtime.getTime(); System.out.println("Elapsed Time is:" + elapsed_time + " millisec onds"); System.out.println(); System.out.println("Changed date object using setTime() method"); System.out.println(); Date chngdate = new Date(); System.out.println("Date before change is: " + chngdate); chngdate.setTime(24L*60L*60L*1000L); System.out.println("Now the Changed date is: " + chngdate); System.out.println(); } public static void main(String[] args) { System.out.println(); DateExample(); } }

OUTPUT

\ E:\User\Manikandan\Experiment 3>java simpledate

************************************

Current Date and Time is : Mon Dec 10 18:39:27 GMT+05:30 2007 Date object showing specific date and time First Particular date : Fri Jan 02 05:30:00 GMT+05:30 1970 Second Particular date: Thu Jan 01 05:30:00 GMT+05:30 1970 Demo of getTime() method returning milliseconds Start Time: Mon Dec 10 18:39:28 GMT+05:30 2007 End Time is: Mon Dec 10 18:39:28 GMT+05:30 2007 Elapsed Time is:0 milliseconds Changed date object using setTime() method Date before change is: Mon Dec 10 18:39:28 GMT+05:30 2007 Now the Changed date is: Fri Jan 02 05:30:00 GMT+05:30 1970

AIM

To develop with suitable hierarchy, classes for Point, Shape, Rectangle, Square, Circle, Ellipse, Triangle, Polygon, etc. Design a simple test application to demonstrate dynamic polymorphism. ALGORITHM

SOURCE CODE

public class Circle implements IShape { private double radius; public Circle(double radius){ this.radius = radius; } public Double getAreaValue() { double area = 2 * 3.14 * radius * radius; return area; } public String getObjectName() { return "Circle"; } }

public class DynamicPolymorphsim { public static void main(String[] args) { System.out.println("********************************************"); System.out.println("\tDynamic Polymorphsim Example"); System.out.println("********************************************"); Circle circleObject = new Circle(2.4); System.out.println("Circle object is created.\n"); Square square = new Square(2); System.out.println("Square object is created.\n"); Rectangular rectangular = new Rectangular(2, 10); System.out.println("Rectangular object is created.\n"); Triangle triangle = new Triangle(3, 2.76); System.out.println("Rectangular object is created.\n"); NonShape ec = new NonShape(); System.out.println("NonShape object is created.\n"); System.out.println("---------------------------------------"); System.out.println(" Calling Dynamic Polymorphsim method"); System.out.println("---------------------------------------"); getShapeObjectDetails(circleObject); getShapeObjectDetails(square); getShapeObjectDetails(rectangular);

getShapeObjectDetails(triangle); getShapeObjectDetails(ec); } public static void getShapeObjectDetails(Object iShape){ if(iShape != null){ if(iShape instanceof IShape){ IShape iShape1 = (IShape)iShape; System.out.println("Area of the "+iShape1.getObjectName() +" = "+iShape1.getAreaValue()); }else{ System.out.println("\nPassed object which is not implemented from IShape Interface"); } } } }

public interface IShape { /** * @return the </code>IShape</code> Object Name */ public String getObjectName(); /** * @return the <b>Area</b> value of the object */ public Double getAreaValue(); }

public class NonShape { public double getAreaValue(){ return 0.0; } public String getObjectName(){ return "test"; }}

public class Rectangular implements IShape {

private double width; private double length; public Rectangular(double width, double length){ this.width = width; this.length = length; } public Double getAreaValue() { return width * length; } public String getObjectName() { return "Rectangular"; } }

public class Square implements IShape { private double size; public Square(double size){ this.size = size; } public Double getAreaValue() { return size * size; } public String getObjectName() { return "Square"; } }

public class Triangle implements IShape { private double base; private double height;

public Triangle(double base, double height){ this.base = base; this.height = height; } public Double getAreaValue() { double area = 0.5 * base * height; return area; } public String getObjectName() { return "Triangle"; } }

OUTPUT E:\User\Manikandan\Experiment 4>javac *.java

E:\User\Manikandan\Experiment 4>java DynamicPolymorphsim ******************************************** Dynamic Polymorphsim Example ******************************************** Circle object is created. Square object is created. Rectangular object is created. Rectangular object is created. NonShape object is created. --------------------------------------Calling Dynamic Polymorphsim method --------------------------------------Area of the Circle = 36.172799999999995 Area of the Square = 4.0 Area of the Rectangular = 20.0 Area of the Triangle = 4.14 Passed object which is not implemented from IShape Interface E:\User\Manikandan\Experiment 4>

AIM To design a Java interface for ADT Stack. Develop two different classes that implement this interface, one using array and the other using linked-list. Provide necessary exception handling in both the implementations.

ALGORITHM

SOURCE CODE
/** * Array-based implementation of the stack.

* @author Durai Murugan */ public class ArrayStack implements Stack { private Object [ ] theArray; private int topOfStack; private static final int DEFAULT_CAPACITY = 10; /** * Construct the stack. */ public ArrayStack( ) { theArray = new Object[ DEFAULT_CAPACITY ]; topOfStack = -1; } /** * Test if the stack is logically empty. * @return true if empty, false otherwise. */ public boolean isEmpty( ) { return topOfStack == -1; } /** * Make the stack logically empty. */ public void makeEmpty( ) { topOfStack = -1; } /** * Get the most recently inserted item in the stack. * Does not alter the stack. * @return the most recently inserted item in the stack. * @throws UnderflowException if the stack is empty. */ public Object top( ) { if( isEmpty( ) ) throw new UnderflowException( "ArrayStack top" ); return theArray[ topOfStack ]; } /** * Remove the most recently inserted item from the stack. * @throws UnderflowException if the stack is empty. */ public void pop( ) { if( isEmpty( ) ) throw new UnderflowException( "ArrayStack pop" ); topOfStack--; } /** * Return and remove the most recently inserted item * from the stack. * @return the most recently inserted item in the stack. * @throws Underflow if the stack is empty.

*/ public Object topAndPop( ) { if( isEmpty( ) ) throw new UnderflowException( "ArrayStack topAndPop" ); return theArray[ topOfStack-- ]; } /** * Insert a new item into the stack. * @param x the item to insert. */ public void push( Object x ) { if( topOfStack + 1 == theArray.length ) doubleArray( ); theArray[ ++topOfStack ] = x; } /** * Internal method to extend theArray. */ private void doubleArray( ) { Object [ ] newArray; newArray = new Object[ theArray.length * 2 ]; for( int i = 0; i < theArray.length; i++ ) newArray[ i ] = theArray[ i ]; theArray = newArray; }

//ListStack class // // CONSTRUCTION: with no initializer //

// // // // // // // // //

******************PUBLIC OPERATIONS********************* void push( x ) --> Insert x void pop( ) --> Remove most recently inserted item Object top( ) --> Return most recently inserted item Object topAndPop( ) --> Return and remove most recent item boolean isEmpty( ) --> Return true if empty; else false void makeEmpty( ) --> Remove all items ******************ERRORS******************************** top, pop, or topAndPop on empty stack

/** * List-based implementation of the stack. * @author Durai Murugan */ public class LinkedListStack implements Stack { /** * Construct the stack. */ public LinkedListStack( ) { topOfStack = null; } /** * Test if the stack is logically empty. * @return true if empty, false otherwise. */ public boolean isEmpty( ) { return topOfStack == null; } /** * Make the stack logically empty. */ public void makeEmpty( ) { topOfStack = null; } /** * Insert a new item into the stack. * @param x the item to insert. */ public void push( Object x ) { topOfStack = new ListNode( x, topOfStack ); } /** * Remove the most recently inserted item from the stack. * @throws UnderflowException if the stack is empty. */ public void pop( ) { if( isEmpty( ) ) throw new UnderflowException( "ListStack pop" ); topOfStack = topOfStack.next; } /** * Get the most recently inserted item in the stack. * Does not alter the stack.

* @return the most recently inserted item in the stack. * @throws UnderflowException if the stack is empty. */ public Object top( ) { if( isEmpty( ) ) throw new UnderflowException( "ListStack top" ); return topOfStack.element; } /** * Return and remove the most recently inserted item * from the stack. * @return the most recently inserted item in the stack. * @throws UnderflowException if the stack is empty. */ public Object topAndPop( ) { if( isEmpty( ) ) throw new UnderflowException( "ListStack topAndPop" ); Object topItem = topOfStack.element; topOfStack = topOfStack.next; return topItem; } private ListNode topOfStack; }

public class ListNode { public Object element; public ListNode next; // Constructors public ListNode( Object theElement ) { this( theElement, null ); } public ListNode( Object theElement, ListNode n ) { element = theElement; next = n; } }

public interface Stack { /** * Insert a new item into the stack. * @param x the item to insert.

*/ void

push( Object x );

/** * Remove the most recently inserted item from the stack. * @exception UnderflowException if the stack is empty. */ void pop( ); /** * Get the most recently inserted item in the stack. * Does not alter the stack. * @return the most recently inserted item in the stack. * @exception UnderflowException if the stack is empty. */ Object top( ); /** * Return and remove the most recently inserted item * from the stack. * @return the most recently inserted item in the stack. * @exception UnderflowException if the stack is empty. */ Object topAndPop( ); /** * Test if the stack is logically empty. * @return true if empty, false otherwise. */ boolean isEmpty( ); /** * Make the stack logically empty. */ void makeEmpty( ); }

public class StackTester { public static void main(String[] args) {

System.out.println("******************************************"); System.out.println("Stack using Array & Linked List example"); System.out.println("******************************************"); ArrayStack arrayStack = new ArrayStack(); arrayStack.push(new String("a")); arrayStack.push(new String("b")); arrayStack.push(new String("c")); System.out.println("Stack[using array] elements -> a, b, c"); System.out.println("Stack LIFO and POP -> "+arrayStack.topAndPop()); System.out.println("Stack LIFO -> "+arrayStack.top()); arrayStack.pop(); try{ arrayStack.pop(); arrayStack.topAndPop(); }catch(RuntimeException rte){ System.err.println("Exception occured while POP operation is happened on Stack[by using array]"); } System.out.println("\n\n******************************"); System.out.println("Stack using Linked List example"); System.out.println("******************************"); LinkedListStack linkedListStack = new LinkedListStack(); linkedListStack.push(new Integer(10)); linkedListStack.push(new Integer(20)); linkedListStack.push(new Integer(30)); linkedListStack.push(new Integer(40)); System.out.println("Stack[using linked list] elements -> 10, 20, 30, 40"); System.out.println("Stack TOP ->"+linkedListStack.top()); linkedListStack.pop(); System.out.println("Stack TOP after POP ->"+linkedListStack.top()); linkedListStack.pop(); linkedListStack.pop(); linkedListStack.pop(); try{ linkedListStack.pop(); }catch(RuntimeException rte){ System.err.println("Exception occured while POP operation is happened on Stack[by using linked list]"); } } } /** * Exception class for access in empty containers * such as stacks, queues, and priority queues. * @author Durai Murugan */

public class UnderflowException extends RuntimeException { /** * Construct this exception object. * @param message the error message. */ public UnderflowException( String message ) { super( message ); } }

OUTPUT E:\User\Manikandan\Experiment 5>javac *.java E:\User\Manikandan\Experiment 5>java StackTester ****************************************** Stack using Array & Linked List example ****************************************** Stack[using array] elements -> a, b, c Stack LIFO and POP -> c Stack LIFO -> b Exception occured while POP operation is happened on Stack[by using array] ****************************** Stack using Linked List example ****************************** Stack[using linked list] elements -> 10, 20, 30, 40 Stack TOP ->40 Stack TOP after POP ->30 Exception occured while POP operation is happened on Stack[by using linked list] E:\User\Manikandan\Experiment 5>

AIM

To write a Java program to read a file that contains DNA sequences of arbitrary length one per line (note that each DNA sequence is just a String). Your program should sort the sequences in descending order with respect to the number of 'GC' ALGORITHM

SOURCE CODE

import import import import import import import import import import

java.io.BufferedOutputStream; java.io.BufferedReader; java.io.File; java.io.FileNotFoundException; java.io.FileOutputStream; java.io.FileReader; java.io.IOException; java.util.ArrayList; java.util.Arrays; java.util.List;

public class FileOperation { /** * subsequence search text */ public static String SEARCH_CONTENT = "GC"; public static void main(String[] args) { String fi = ".\\file\\input.txt"; String out = ".\\file\\output.txt";

System.out.println("****************************************************" ); System.out.println(" DNA sequence example by File Read/Write Operation"); System.out.println("***************************************************** "); FileOperation fo = new FileOperation(); String content = fo.getFileContent(fi); fo.writeTextToFile(content, out); } public void writeTextToFile(String content, String filePath){ File outFile = null; FileOutputStream fis = null; BufferedOutputStream bos = null; outFile = new File(filePath); try { System.out.println("\nSorted contents are written into "+outFile.getCanonicalPath()); fis = new FileOutputStream(outFile); bos = new BufferedOutputStream(fis); bos.write(content.getBytes()); bos.close(); } catch (IOException e) { e.printStackTrace(); } } public String getFileContent(String filePath) {

String content = null; File file = new File(filePath); FileReader fr = null; BufferedReader br = null; List<FileContent> listFileContent = new ArrayList<FileContent>(); try { System.out.println("DNA Sequence file is located from ["+file.getCanonicalPath()+"]"); System.out.println("\n----------------------------------------------------------------------"); fr = new FileReader(file); br = new BufferedReader(fr); int i = 0; String lineString = br.readLine(); while(lineString != null){ System.out.println(lineString); //System.out.println(" bb --> "+ getSeqCount(lineString, "GC")); FileContent fileContent = new FileContent(i++, getSeqCount(lineString, SEARCH_CONTENT), lineString); listFileContent.add(fileContent); lineString = br.readLine(); } fr.close(); br.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } System.out.println("----------------------------------------------------------------------"); System.out.println("Contents are loaded to find SubSequences of '"+SEARCH_CONTENT+"' for sorting the DNA contents"); content = sortLines(listFileContent); System.out.println("\nDNA Sequence contents are sorted....."); return content; } public String sortLines(List<FileContent> listFileContents){ List<FileContent> _lstFileContent = listFileContents; StringBuffer stringBuffer = new StringBuffer(); int [] seqCntArray = new int [listFileContents.size()+1]; int i = 0; for(FileContent fileContent : _lstFileContent){ seqCntArray[i++] = fileContent.getSeqCount(); } /*SORTING THE ARRAY */ Arrays.sort(seqCntArray);

for(int itr = seqCntArray.length; itr > 0 ; itr--){ for(int j=0; j < _lstFileContent.size() ; j++){ FileContent fileContent = listFileContents.get(j); if(fileContent.getSeqCount() == seqCntArray[itr1]){ //System.out.println(" contents -["+fileContent.getLineString()+"] "+fileContent.getSeqCount()); stringBuffer.append(fileContent.getLineString()+"\n"); listFileContents.remove(fileContent); } } } return stringBuffer.toString(); } public int getSeqCount(String lineString, String text){ int seqCount = 0; if(lineString != null && text != null && lineString.contains(text)){ int strLen = lineString.length(); String [] textSplit = lineString.split(text); //System.out.println(" length --"+textSplit.length); if(textSplit == null){ return seqCount; }else { seqCount = textSplit.length - 1; } } return seqCount; } } class FileContent{ private int lineNumber; private int seqCount; private String lineString; /** * Parameterized Consatructor * @param seqCount * @param lineString */ public FileContent(int lineNumber, int seqCount, String lineString) { super(); this.lineNumber = lineNumber; this.seqCount = seqCount; this.lineString = lineString; } /** * @return the seqCount */ public int getSeqCount() { return seqCount;

} /** * @param seqCount the seqCount to set */ public void setSeqCount(int seqCount) { this.seqCount = seqCount; } /** * @return the lineString */ public String getLineString() { return lineString; } /** * @param lineString the lineString to set */ public void setLineString(String lineString) { this.lineString = lineString; } /** * @return the lineNumber */ public int getLineNumber() { return lineNumber; } /** * @param lineNumber the lineNumber to set */ public void setLineNumber(int lineNumber) { this.lineNumber = lineNumber; }

OUTPUT INPUT FILE

ACAAGATGCCATTGTCCCCCGGCCTCCTGCTGCTGCTGCTCTCCGGGGCCACGGCCACCGCTGCCCTGCC CCTGGAGGGTGGCCCCACCGGCCGAGACAGCGAGCATATGCAGGAAGCGGCAGGAATAAGGAAAAGCAGC CTCCTGACTTTCCTCGCTTGGTGGTTTGAGTGGACCTCCCAGGCCAGTGCCGGGCCCCTCATAGGAGAGG AAGCTCGGGAGGTGGCCAGGCGGCAGGAAGGCGCACCCCCCCAGCAATCCGCGCGCCGGGACAGAATGCC CTGCAGGAACTTCTTCTGGAAGACCTTCTCCTCCTGCAAATAAAACCTCACCCATGAATGCTCACGCAAG TTTAATTACAGACCTGAA

OUTPUT FILE
ACAAGATGCCATTGTCCCCCGGCCTCCTGCTGCTGCTGCTCTCCGGGGCCACGGCCACCGCTGCCCTGCC AAGCTCGGGAGGTGGCCAGGCGGCAGGAAGGCGCACCCCCCCAGCAATCCGCGCGCCGGGACAGAATGCC CCTGGAGGGTGGCCCCACCGGCCGAGACAGCGAGCATATGCAGGAAGCGGCAGGAATAAGGAAAAGCAGC CTCCTGACTTTCCTCGCTTGGTGGTTTGAGTGGACCTCCCAGGCCAGTGCCGGGCCCCTCATAGGAGAGG CTGCAGGAACTTCTTCTGGAAGACCTTCTCCTCCTGCAAATAAAACCTCACCCATGAATGCTCACGCAAG TTTAATTACAGACCTGAA

E:\User\Manikandan\Experimrnt 6>java FileOperation **************************************************** DNA sequence example by File Read/Write Operation ***************************************************** DNA Sequence file is located from [E:\User\Manikandan\Experimrnt 6\file\input.txt] ----------------------------------------------------------------------ACAAGATGCCATTGTCCCCCGGCCTCCTGCTGCTGCTGCTCTCCGGGGCCACGGCCACCGCTGCCCTGCC CCTGGAGGGTGGCCCCACCGGCCGAGACAGCGAGCATATGCAGGAAGCGGCAGGAATAAGGAAAAGCAGC CTCCTGACTTTCCTCGCTTGGTGGTTTGAGTGGACCTCCCAGGCCAGTGCCGGGCCCCTCATAGGAGAGG AAGCTCGGGAGGTGGCCAGGCGGCAGGAAGGCGCACCCCCCCAGCAATCCGCGCGCCGGGACAGAATGCC CTGCAGGAACTTCTTCTGGAAGACCTTCTCCTCCTGCAAATAAAACCTCACCCATGAATGCTCACGCAAG TTTAATTACAGACCTGAA ----------------------------------------------------------------------Contents are loaded to find SubSequences of 'GC' for sorting the DNA contents DNA Sequence contents are sorted..... Sorted contents are written into E:\User\Manikandan\Experimrnt 6\file\output.txt E:\User\Manikandan\Experimrnt 6>

AIM To develop a simple paint-like program that can draw basic graphical primitives in different dimensions and colors. Use appropriate menu and buttons. ALGORITHM

SOURCE CODE
/** This is the abstract parent class for different shape classes, like rectangle, oval, polygon and triangle. It provides an abstract method draw(). */ import java.util.*; import java.awt.*; public abstract class Shapes { /**abstract method draw() @return void */ public abstract void draw(java.util.List list, Graphics g); } //different implementations of Shape class class RectangleShape extends Shapes { Point sPoint = null; Point ePoint = null; public void draw(java.util.List list, Graphics g) { Iterator it = list.iterator(); //if the list does not contain the required two points, return. if(list.size()<2) { return; } sPoint = (Point)it.next(); ePoint = (Point)it.next(); if(sPoint == null || ePoint == null) { return; } else { g.fillRect((int)sPoint.getX(), (int)sPoint.getY(), (int) (ePoint.getX()-sPoint.getX()), (int)(ePoint.getY()-sPoint.getY())); }//end of if list.clear(); }//end of draw for rectangle }//rectangle class OvalShape extends Shapes { Point sPoint = null; Point ePoint = null; public void draw(java.util.List list, Graphics g) { Iterator it = list.iterator();

//if the list does not contain the required two points, return. if(list.size()<2) { return; } sPoint = (Point)it.next(); ePoint = (Point)it.next(); if(sPoint == null || ePoint == null) { return; } else { g.fillOval((int)sPoint.getX(), (int)sPoint.getY(), (int) (ePoint.getX()-sPoint.getX()), (int)(ePoint.getY()-sPoint.getY())); }//end of if list.clear(); }//end of draw for Oval }//OvalShape class TriangleShape extends Shapes { public void draw(java.util.List list, Graphics g) { Point point = null; Iterator it = list.iterator(); //if the list does not contain the required two points, return. if(list.size()<3) { return; } Polygon p = new Polygon(); for(int i = 0; i < 3; i++) { point = (Point)it.next(); p.addPoint((int)point.getX(), (int)point.getY()); } g.fillPolygon(p); list.clear(); }//end of draw for Triangle }//Triangle class PolygonShape extends Shapes { public void draw(java.util.List list, Graphics g) { Point point = null; Iterator it = list.iterator(); //if the list does not contain the required two points, return. if(list.size()<3) { return; } Polygon p = new Polygon(); for(;it.hasNext();) { point = (Point)it.next(); p.addPoint((int)point.getX(), (int)point.getY());

} g.fillPolygon(p); list.clear(); }//end of draw for Polygon }//Polygon

import import import import import import import import import import import import import import import import import

java.awt.Color; java.awt.Dimension; java.awt.Frame; java.awt.Graphics; java.awt.Insets; java.awt.Menu; java.awt.MenuBar; java.awt.MenuItem; java.awt.MenuShortcut; java.awt.Panel; java.awt.Point; java.awt.event.ActionEvent; java.awt.event.ActionListener; java.awt.event.MouseEvent; java.awt.event.MouseListener; java.awt.event.WindowAdapter; java.awt.event.WindowEvent;

import javax.swing.JOptionPane; public class SimpleDrawingTool extends Frame{ //constants for menu private static final private static final private static final private static final private static final private static final private static final private private private private shortcuts int kControlA int kControlD int kControlC int kControlR int kControlP int kControlT int kControlX = = = = = = = 65; 68; 67; 82; 80; 84; 88;

RectangleShape rectangle = new RectangleShape(); OvalShape oval = new OvalShape(); PolygonShape polygon = new PolygonShape(); TriangleShape triangle = new TriangleShape();

private DrawingPanel panel; public SimpleDrawingTool() { //set frame's title super("Simple Drawing Tool"); //add menu addMenu(); //add drawing panel addPanel(); //add window listener this.addWindowListener(new WindowHandler());

//set frame size this.setSize(400, 400); //make this frame visible this.setVisible(true); } public static void main(String[] args) { SimpleDrawingTool simpleDrawingTool = new SimpleDrawingTool(); } /** This method creates menu bar and menu items and then attach the menu bar with the frame of this drawing tool. */ private void addMenu() { //Add menu bar to our frame MenuBar menuBar = new MenuBar(); Menu file = new Menu("File"); Menu shape = new Menu("Shapes"); Menu about = new Menu("About"); //now add menu items to these Menu objects file.add(new MenuItem("Exit", new MenuShortcut(kControlX))).addActionListener(new WindowHandler()); shape.add(new MenuItem("Rectangle", new MenuShortcut(kControlR))).addActionListener(new shape.add(new MenuItem("Circle", new MenuShortcut(kControlC))).addActionListener(new shape.add(new MenuItem("Triangle", new MenuShortcut(kControlT))).addActionListener(new shape.add(new MenuItem("Polygon", new MenuShortcut(kControlP))).addActionListener(new shape.add(new MenuItem("Draw Polygon", new MenuShortcut(kControlD))).addActionListener(new WindowHandler()); WindowHandler()); WindowHandler()); WindowHandler()); WindowHandler());

about.add(new MenuItem("About", new MenuShortcut(kControlA))).addActionListener(new WindowHandler()); //add menus to menubar menuBar.add(file); menuBar.add(shape); menuBar.add(about); //menuBar.setVisible(true); if(null == this.getMenuBar()) { this.setMenuBar(menuBar); } }//addMenu() /** This method adds a panel to SimpleDrawingTool for drawing shapes. */ private void addPanel() { panel = new DrawingPanel(); //get size of SimpleDrawingTool frame Dimension d = this.getSize(); //get insets of frame

Insets ins = this.insets(); //exclude insets from the size of the panel d.height = d.height - ins.top - ins.bottom; d.width = d.width - ins.left - ins.right; panel.setSize(d); panel.setLocation(ins.left, ins.top); panel.setBackground(Color.white); //add mouse listener. Panel itself will be handling mouse events panel.addMouseListener(panel); this.add(panel); }//end of addPanel(); //Inner class to handle events private class WindowHandler extends WindowAdapter implements ActionListener { public void windowClosing(WindowEvent e) { System.exit(0); } public void actionPerformed(ActionEvent e) { //check to see if the action command is equal to exit if(e.getActionCommand().equalsIgnoreCase("exit")) { System.exit(0); } else if(e.getActionCommand().equalsIgnoreCase("Rectangle")) { Menu menu = getMenuBar().getMenu(1); for(int i = 0;i < menu.getItemCount();menu.getItem(i).setEnabled(true),i++); getMenuBar().getShortcutMenuItem(new MenuShortcut(kControlR)).setEnabled(false); panel.drawShape(rectangle); } else if(e.getActionCommand().equalsIgnoreCase("Circle")) { Menu menu = getMenuBar().getMenu(1); for(int i = 0;i < menu.getItemCount();menu.getItem(i).setEnabled(true),i++); getMenuBar().getShortcutMenuItem(new MenuShortcut(kControlC)).setEnabled(false); panel.drawShape(oval); } else if(e.getActionCommand().equalsIgnoreCase("Triangle")) { Menu menu = getMenuBar().getMenu(1); for(int i = 0;i < menu.getItemCount();menu.getItem(i).setEnabled(true),i++); getMenuBar().getShortcutMenuItem(new MenuShortcut(kControlT)).setEnabled(false); panel.drawShape(triangle); } else if(e.getActionCommand().equalsIgnoreCase("Polygon")) {

Menu menu = getMenuBar().getMenu(1); for(int i = 0;i < menu.getItemCount();menu.getItem(i).setEnabled(true),i++); getMenuBar().getShortcutMenuItem(new MenuShortcut(kControlP)).setEnabled(false); panel.drawShape(polygon); } else if(e.getActionCommand().equalsIgnoreCase("Draw Polygon")) { Menu menu = getMenuBar().getMenu(1); for(int i = 0;i < menu.getItemCount();menu.getItem(i).setEnabled(true),i++); getMenuBar().getShortcutMenuItem(new MenuShortcut(kControlP)).setEnabled(false); panel.repaint(); } else if(e.getActionCommand().equalsIgnoreCase("About")) { JOptionPane.showMessageDialog(null, "This small paint-like program.", "About", JOptionPane.PLAIN_MESSAGE); } }//actionPerformed() }//windowHandler - Inner Class ends here }//SimpleDrawingTool class DrawingPanel extends Panel implements MouseListener { private Point sPoint = null; private Point ePoint = null; private Shapes shape = null; private java.util.ArrayList list = new java.util.ArrayList(); //override panel paint method to draw shapes public void paint(Graphics g) { g.setColor(Color.green); shape.draw(list, g); } public void drawShape(Shapes shape) { this.shape = shape; } //define mouse handler public void mouseClicked(MouseEvent e) { //if user wants to draw triangle, call repaint after 3 clicks if(shape instanceof TriangleShape) { list.add(e.getPoint()); if(list.size() > 2) { repaint(); } } else if(shape instanceof PolygonShape) { list.add(e.getPoint());

} }//mouseClicked public void mouseEntered(MouseEvent e){} public void mouseExited(MouseEvent e){} public void mousePressed(MouseEvent e) { sPoint = e.getPoint(); }//mousePressed public void mouseReleased(MouseEvent e) { ePoint = e.getPoint(); if(ePoint.getX() < sPoint.getX()) { Point temp = ePoint; ePoint = sPoint; sPoint = temp; } if(ePoint.getY() < sPoint.getY()) { int temp = (int)ePoint.getY(); ePoint.y = (int)sPoint.getY(); sPoint.y = temp; } if(shape instanceof RectangleShape || shape instanceof OvalShape) { list.clear(); list.add(sPoint); list.add(ePoint); repaint(); } }//mouseReleased }//DrawingPanel

OUTPUT

AIM To develop a scientific calculator using even-driven programming paradigm of Java. ALGORITHM

SOURCE CODE

import import import import import import import import import import import import import import import import import import import import import import

java.awt.BorderLayout; java.awt.Color; java.awt.Container; java.awt.FlowLayout; java.awt.Font; java.awt.GridLayout; java.awt.Window; java.awt.event.ActionEvent; java.awt.event.ActionListener; java.awt.event.KeyEvent; java.awt.event.WindowAdapter; java.awt.event.WindowEvent; javax.swing.JButton; javax.swing.JDialog; javax.swing.JFrame; javax.swing.JLabel; javax.swing.JMenu; javax.swing.JMenuBar; javax.swing.JMenuItem; javax.swing.JPanel; javax.swing.JTextArea; javax.swing.KeyStroke;

public class Calculator extends JFrame implements ActionListener { // Variables final int MAX_INPUT_LENGTH = 20; final int INPUT_MODE = 0; final int RESULT_MODE = 1; final int ERROR_MODE = 2; int displayMode; boolean clearOnNextDigit, percent; double lastNumber; String lastOperator; private JMenu jmenuFile, jmenuHelp; private JMenuItem jmenuitemExit, jmenuitemAbout; private JLabel jlbOutput; private JButton jbnButtons[]; private JPanel jplMaster, jplBackSpace, jplControl; /* * Font(String name, int style, int size) Creates a new Font from the specified name, style and point size. */ Font f12 = new Font("Times New Roman", 0, 12); Font f121 = new Font("Times New Roman", 1, 12); // Constructor public Calculator() { /* Set Up the JMenuBar. * Have Provided All JMenu's with Mnemonics * Have Provided some JMenuItem components with Keyboard Accelerators */ jmenuFile = new JMenu("File"); jmenuFile.setFont(f121); jmenuFile.setMnemonic(KeyEvent.VK_F); jmenuitemExit = new JMenuItem("Exit"); jmenuitemExit.setFont(f12); jmenuitemExit.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_X, ActionEvent.CTRL_MASK)); jmenuFile.add(jmenuitemExit); jmenuHelp = new JMenu("Help"); jmenuHelp.setFont(f121); jmenuHelp.setMnemonic(KeyEvent.VK_H); jmenuitemAbout = new JMenuItem("About Calculator"); jmenuitemAbout.setFont(f12); jmenuHelp.add(jmenuitemAbout); JMenuBar mb = new JMenuBar();

mb.add(jmenuFile); mb.add(jmenuHelp); setJMenuBar(mb); //Set frame layout manager setBackground(Color.gray); jplMaster = new JPanel(); jlbOutput = new JLabel("0"); jlbOutput.setHorizontalTextPosition(JLabel.RIGHT); jlbOutput.setBackground(Color.WHITE); jlbOutput.setOpaque(true); // Add components to frame getContentPane().add(jlbOutput, BorderLayout.NORTH); // Jbuttons // Create numeric Jbuttons for (int i=0; i<=9; i++) { // set each Jbutton label to the value of index jbnButtons[i] = new JButton(String.valueOf(i)); } // Create operator Jbuttons jbnButtons[10] = new JButton("+/-"); jbnButtons[11] = new JButton("."); jbnButtons[12] = new JButton("="); jbnButtons[13] = new JButton("/"); jbnButtons[14] = new JButton("*"); jbnButtons[15] = new JButton("-"); jbnButtons[16] = new JButton("+"); jbnButtons[17] = new JButton("sqrt"); jbnButtons[18] = new JButton("1/x"); jbnButtons[19] = new JButton("%"); jplBackSpace = new JPanel(); jplBackSpace.setLayout(new GridLayout(1, 1, 2, 2)); jbnButtons[20] = new JButton("Backspace"); jplBackSpace.add(jbnButtons[20]); jplControl = new JPanel(); jplControl.setLayout(new GridLayout(1, 2, 2 ,2)); jbnButtons[21] = new JButton(" CE "); jbnButtons[22] = new JButton("C"); jplControl.add(jbnButtons[21]); jplControl.add(jbnButtons[22]); jbnButtons = new JButton[23]; GridLayout(int rows, int cols, int hgap, int vgap) JPanel jplButtons = new JPanel(); // container for

//

Setting all Numbered JButton's to Blue. The rest to Red for (int i=0; i<jbnButtons.length; i++) { jbnButtons[i].setFont(f12); if (i<10) jbnButtons[i].setForeground(Color.blue); else jbnButtons[i].setForeground(Color.red); } // Set panel layout manager for a 4 by 5 grid jplButtons.setLayout(new GridLayout(4, 5, 2, 2)); //Add buttons to keypad panel starting at top left // First row for(int i=7; i<=9; i++) { jplButtons.add(jbnButtons[i]); } // add button / and sqrt jplButtons.add(jbnButtons[13]); jplButtons.add(jbnButtons[17]); // Second row for(int i=4; i<=6; i++) { jplButtons.add(jbnButtons[i]); } // add button * and x^2 jplButtons.add(jbnButtons[14]); jplButtons.add(jbnButtons[18]); // Third row for( int i=1; i<=3; i++) { jplButtons.add(jbnButtons[i]); } //adds button - and % jplButtons.add(jbnButtons[15]); jplButtons.add(jbnButtons[19]); //Fourth Row // add 0, +/-, ., +, and = jplButtons.add(jbnButtons[0]); jplButtons.add(jbnButtons[10]); jplButtons.add(jbnButtons[11]); jplButtons.add(jbnButtons[16]); jplButtons.add(jbnButtons[12]); jplMaster.setLayout(new BorderLayout()); jplMaster.add(jplBackSpace, BorderLayout.WEST); jplMaster.add(jplControl, BorderLayout.EAST); jplMaster.add(jplButtons, BorderLayout.SOUTH); // Add components to frame

getContentPane().add(jplMaster, BorderLayout.SOUTH); requestFocus(); //activate ActionListener for (int i=0; i<jbnButtons.length; i++){ jbnButtons[i].addActionListener(this); } jmenuitemAbout.addActionListener(this); jmenuitemExit.addActionListener(this); clearAll(); //add WindowListener for closing frame and ending program addWindowListener(new WindowAdapter() { public void windowClosed(WindowEvent e) { System.exit(0); } } } ); //End of Contructor Calculator

// Perform action public void actionPerformed(ActionEvent e){ double result = 0; if(e.getSource() == jmenuitemAbout){ JDialog dlgAbout = new CustomABOUTDialog(this, "About Java Swing Calculator", true); dlgAbout.setVisible(true); }else if(e.getSource() == jmenuitemExit){ System.exit(0); } // Search for the button pressed until end of array or key found for (int i=0; i<jbnButtons.length; i++) { if(e.getSource() == jbnButtons[i]) { switch(i) { case 0: addDigitToDisplay(i); break; case 1: addDigitToDisplay(i); break; case 2: addDigitToDisplay(i); break; case 3:

addDigitToDisplay(i); break; case 4: addDigitToDisplay(i); break; case 5: addDigitToDisplay(i); break; case 6: addDigitToDisplay(i); break; case 7: addDigitToDisplay(i); break; case 8: addDigitToDisplay(i); break; case 9: addDigitToDisplay(i); break; case 10: // +/processSignChange(); break; case 11: // decimal point addDecimalPoint(); break; case 12: // = processEquals(); break; case 13: // divide processOperator("/"); break; case 14: // * processOperator("*"); break; case 15: // processOperator("-"); break; case 16: // + processOperator("+"); break; case 17: // sqrt if (displayMode != ERROR_MODE) {

try { if (getDisplayString().indexOf("-") == 0) displayError("Invalid input for function!"); result = Math.sqrt(getNumberInDisplay()); displayResult(result); } catch(Exception ex) { displayError("Invalid input for function!"); displayMode = ERROR_MODE; } } break; case 18: // 1/x if (displayMode != ERROR_MODE){ try { if (getNumberInDisplay() == 0) displayError("Cannot divide by zero!"); result = 1 / getNumberInDisplay(); displayResult(result); } catch(Exception ex) { displayError("Cannot divide by zero!"); displayMode = ERROR_MODE; } } break; case 19: // % if (displayMode != ERROR_MODE){ try { result = getNumberInDisplay() / 100; displayResult(result); } catch(Exception ex) { displayError("Invalid input for function!"); displayMode = ERROR_MODE; } } break;

case 20: // backspace if (displayMode != ERROR_MODE){ setDisplayString(getDisplayString().substring(0, getDisplayString().length() - 1)); if (getDisplayString().length() < 1) setDisplayString("0"); } break; case 21: // CE clearExisting(); break; case 22: // C clearAll(); break; } } } } void setDisplayString(String s){ jlbOutput.setText(s); } String getDisplayString (){ return jlbOutput.getText(); } void addDigitToDisplay(int digit){ if (clearOnNextDigit) setDisplayString(""); String inputString = getDisplayString(); if (inputString.indexOf("0") == 0){ inputString = inputString.substring(1); } if ((!inputString.equals("0") || digit > 0) && inputString.length() < MAX_INPUT_LENGTH){ setDisplayString(inputString + digit); } displayMode = INPUT_MODE; clearOnNextDigit = false; } void addDecimalPoint(){ displayMode = INPUT_MODE;

if (clearOnNextDigit) setDisplayString(""); String inputString = getDisplayString(); // If the input string already contains a decimal point, don't // do anything to it. if (inputString.indexOf(".") < 0) setDisplayString(new String(inputString + ".")); } void processSignChange(){ if (displayMode == INPUT_MODE) { String input = getDisplayString(); if (input.length() > 0 && !input.equals("0")) { if (input.indexOf("-") == 0) setDisplayString(input.substring(1)); else setDisplayString("-" + input); } } else if (displayMode == RESULT_MODE) { double numberInDisplay = getNumberInDisplay(); if (numberInDisplay != 0) displayResult(-numberInDisplay); } } void clearAll() { setDisplayString("0"); lastOperator = "0"; lastNumber = 0; displayMode = INPUT_MODE; clearOnNextDigit = true; } void clearExisting(){ setDisplayString("0"); clearOnNextDigit = true; displayMode = INPUT_MODE; } double getNumberInDisplay() { String input = jlbOutput.getText(); return Double.parseDouble(input); } void processOperator(String op) { if (displayMode != ERROR_MODE)

{ double numberInDisplay = getNumberInDisplay(); if (!lastOperator.equals("0")) { try { double result = processLastOperator(); displayResult(result); lastNumber = result; } catch (DivideByZeroException e) { } } else { lastNumber = numberInDisplay; } clearOnNextDigit = true; lastOperator = op; } } void processEquals(){ double result = 0; if (displayMode != ERROR_MODE){ try { result = processLastOperator(); displayResult(result); } catch (DivideByZeroException e) { displayError("Cannot divide by zero!"); } lastOperator = "0"; } } double processLastOperator() throws DivideByZeroException { double result = 0; double numberInDisplay = getNumberInDisplay(); if (lastOperator.equals("/")) { if (numberInDisplay == 0) throw (new DivideByZeroException()); result = lastNumber / numberInDisplay; } if (lastOperator.equals("*"))

result = lastNumber * numberInDisplay; if (lastOperator.equals("-")) result = lastNumber - numberInDisplay; if (lastOperator.equals("+")) result = lastNumber + numberInDisplay; return result; } void displayResult(double result){ setDisplayString(Double.toString(result)); lastNumber = result; displayMode = RESULT_MODE; clearOnNextDigit = true; } void displayError(String errorMessage){ setDisplayString(errorMessage); lastNumber = 0; displayMode = ERROR_MODE; clearOnNextDigit = true; } public static void main(String args[]) { Calculator calci = new Calculator(); Container contentPane = calci.getContentPane(); contentPane.setLayout(new BorderLayout()); calci.setTitle("Java Swing Calculator"); calci.setSize(241, 217); calci.pack(); calci.setLocation(400, 250); calci.setVisible(true); calci.setResizable(false); } //End of Swing Calculator Class.

//

class DivideByZeroException extends Exception{ public DivideByZeroException() { super(); } public DivideByZeroException(String s) { super(s); } } class CustomABOUTDialog extends JDialog implements ActionListener { JButton jbnOk; CustomABOUTDialog(JFrame parent, String title, boolean modal){ super(parent, title, modal); setBackground(Color.black);

JPanel p1 = new JPanel(new FlowLayout(FlowLayout.CENTER)); StringBuffer text = new StringBuffer(); text.append("Calculator Demo Program\n\n"); JTextArea jtAreaAbout = new JTextArea(5, 21); jtAreaAbout.setText(text.toString()); jtAreaAbout.setFont(new Font("Times New Roman", 1, 13)); jtAreaAbout.setEditable(false); p1.add(jtAreaAbout); p1.setBackground(Color.red); getContentPane().add(p1, BorderLayout.CENTER); JPanel p2 = new JPanel(new FlowLayout(FlowLayout.CENTER)); jbnOk = new JButton(" OK "); jbnOk.addActionListener(this); p2.add(jbnOk); getContentPane().add(p2, BorderLayout.SOUTH); setLocation(408, 270); setResizable(false); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { Window aboutDialog = e.getWindow(); aboutDialog.dispose(); } } ); pack(); } public void actionPerformed(ActionEvent e) { if(e.getSource() == jbnOk) { this.dispose(); } } }

OUTPUT

AIM To develop a template for linked-list class along with its methods in Java. ALGORITHM

SOURCE CODE
public class LinkedList { ListNode current; /** * Construct the list */ public LinkedList( ) { header = new ListNode( null ); } /** * Test if the list is logically empty. * @return true if empty, false otherwise. */ public boolean isEmpty( ) { return header.next == null; } /**

* Make the list logically empty. */ public void makeEmpty( ) { header.next = null; } /** * Return an iterator representing the header node. */ public LinkedListIterator zeroth( ) { return new LinkedListIterator( header ); } /** * Return an iterator representing the first node in the list. * This operation is valid for empty lists. */ public LinkedListIterator first( ) { return new LinkedListIterator( header.next ); } /** * Insert after p. * @param x the item to insert. * @param p the position prior to the newly inserted item. */ public void insert( Object x, LinkedListIterator p ) { if( p != null && p.current != null ) p.current.next = new ListNode( x, p.current.next ); } /** * Return iterator corresponding to the first node containing an item. * @param x the item to search for. * @return an iterator; iterator is not valid if item is not found. */ public LinkedListIterator find( Object x ) { ListNode itr = header.next; while( itr != null && !itr.element.equals( x ) ) itr = itr.next; return new LinkedListIterator( itr ); } /** * Return iterator prior to the first node containing an item. * @param x the item to search for. * @return appropriate iterator if the item is found. Otherwise, the * iterator corresponding to the last element in the list is returned. */ public LinkedListIterator findPrevious( Object x ) { ListNode itr = header; while( itr.next != null && !itr.next.element.equals( x ) )

itr = itr.next; return new LinkedListIterator( itr ); } /** * Remove the first occurrence of an item. * @param x the item to remove. */ public void remove( Object x ) { LinkedListIterator p = findPrevious( x ); if( p.current.next != null ) p.current.next = p.current.next.next; deleted node } // Bypass

// Simple print method public static void printList( LinkedList theList ) { if( theList.isEmpty( ) ) System.out.print( "Empty list" ); else { LinkedListIterator itr = theList.first( ); for( ; itr.isValid( ); itr.advance( ) ) System.out.print( itr.retrieve( ) + " " ); } System.out.println( ); } private ListNode header; // In this routine, LinkedList and LinkedListIterator are the // classes written in Section 17.2. public static int listSize( LinkedList theList ) { LinkedListIterator itr; int size = 0; for( itr = theList.first(); itr.isValid(); itr.advance() ) size++; return size; } public static void main( String [ ] args ) { LinkedList theList = new LinkedList( ); LinkedListIterator theItr; int i; theItr = theList.zeroth( ); printList( theList ); for( i = 0; i < 10; i++ ) { theList.insert( new Integer( i ), theItr ); printList( theList ); theItr.advance( ); } System.out.println( "Size was: " + listSize( theList ) );

for( i = 0; i < 10; i += 2 ) theList.remove( new Integer( i ) ); for( i = 0; i < 10; i++ ) if( ( i % 2 == 0 ) == ( theList.find( new Integer( i ) ).isValid( ) ) ) System.out.println( "Find fails!" ); System.out.println( "Finished deletions" ); printList( theList ); } }

public class LinkedListIterator { ListNode current; /** * Construct the list iterator * @param theNode any node in the linked list. */ LinkedListIterator( ListNode theNode ) { current = theNode; } /** * Test if the current position is a valid position in the list. * @return true if the current position is valid. */ public boolean isValid( ) { return current != null; } /** * Return the item stored in the current position. * @return the stored item or null if the current position * is not in the list. */ public Object retrieve( ) { return isValid( ) ? current.element : null; } /** * Advance the current position to the next node in the list. * If the current position is null, then do nothing. */ public void advance( ) { if( isValid( ) ) current = current.next;

} }

public class ListNode { public Object element; public ListNode next; // Constructors public ListNode( Object theElement ) { this( theElement, null ); } public ListNode( Object theElement, ListNode n ) { element = theElement; next = n; } }

OUTPUT E:\User\Manikandan\Experiment 9>javac *.java E:\User\Manikandan\Experiment 9>java LinkedList Empty list 0 01 012 0123 01234 012345 0123456 01234567 012345678 0123456789 Size was: 10 Finished deletions 13579 E:\User\Manikandan\Experiment 9>

AIM To design a thread-safe implementation of Queue class. Write a multi-threaded producer-consumer application that uses this Queue class. ALGORITHM

SOURCE CODE
public class Consumer extends Thread { private CubbyHole cubbyhole; private int number; public Consumer(CubbyHole c, int number) { cubbyhole = c; this.number = number; } public void run() { int value = 0; for (int i = 0; i < 100; i++) { value = cubbyhole.get(); System.out.println("Consumer #" + this.number + " got: " + value); } } }

public class CubbyHole { private int contents; private boolean available = false; public synchronized int get() { while (available == false) { try { wait(); } catch (InterruptedException e) { } } available = false; notifyAll(); return contents; } public synchronized void put(int value) { while (available == true) { try { wait(); } catch (InterruptedException e) { } } contents = value; available = true; notifyAll(); } }

public class Producer extends Thread { private CubbyHole cubbyhole; private int number; public Producer(CubbyHole c, int number) { cubbyhole = c; this.number = number; } public void run() { for (int i = 0; i < 10; i++) { cubbyhole.put(i); System.out.println("Producer #" + this.number + " put: " + i); try { sleep((int)(Math.random() * 100)); } catch (InterruptedException e) { } } } }

public class ProducerConsumerTest { public static void main(String[] args) { CubbyHole c = new CubbyHole(); Producer p1 = new Producer(c, 1); Consumer c1 = new Consumer(c, 1); p1.start(); c1.start(); }

OUTPUT E:\User\Manikandan\Experiment 10>java ProducerConsumerTest Producer #1 put: 0 Consumer #1 got: 0 Producer #1 put: 1 Consumer #1 got: 1 Producer #1 put: 2 Consumer #1 got: 2 Consumer #1 got: 3 Producer #1 put: 3 Producer #1 put: 4 Consumer #1 got: 4 Producer #1 put: 5 Consumer #1 got: 5 Producer #1 put: 6 Consumer #1 got: 6 Producer #1 put: 7 Consumer #1 got: 7 Producer #1 put: 8 Consumer #1 got: 8 Producer #1 put: 9

Consumer #1 got: 9

AIM To write a multi-threaded Java program to print all numbers below 100,000 that are both prime and Fibonacci number (some examples are 2, 3, 5, 13, etc.). Design a thread that generates prime numbers below 100,000 and writes them into a pipe. Design another thread that generates fibonacci numbers and writes them to another pipe. The main thread should read both the pipes to identify numbers common to both. ALGORITHM

SOURCE CODE
import java.io.DataOutputStream; import java.io.IOException; import java.io.PipedOutputStream; public class FibonacciNumberGenerator extends Thread { private DataOutputStream dos; public FibonacciNumberGenerator(ThreadGroup threadGroup ,PipedOutputStream pis, String name){ super(threadGroup, name); dos = new DataOutputStream(pis); } @Override public void run() { try { for(int k=0; k<10000; k++){ long fibonacciNum = fib(k); if(fibonacciNum > 0L && fibonacciNum < 10000L){

dos.writeLong(fibonacciNum); dos.flush(); } } } catch (IOException e) { } } public int fib(int n) { int prev1=0, prev2=1; for(int i=0; i<n; i++) { int savePrev1 = prev1; prev1 = prev2; prev2 = savePrev1 + prev2; } return prev1; } }

import import import import

java.io.DataInputStream; java.io.IOException; java.io.PipedInputStream; java.io.PipedOutputStream;

public class PipedStreamTester extends Thread { DataInputStream fibonicPis; DataInputStream primePis; public PipedStreamTester(PipedInputStream fibonicPis, PipedInputStream primePis){ this.fibonicPis = new DataInputStream(fibonicPis); this.primePis = new DataInputStream(primePis); }

public static void main(String[] args) { try { PipedOutputStream fibonicPos = new PipedOutputStream(); PipedInputStream fibonicPis = new PipedInputStream(fibonicPos); PipedOutputStream primePos = new PipedOutputStream(); PipedInputStream primePis = new PipedInputStream(primePos); ThreadGroup tg = new ThreadGroup("PipedThreads"); FibonacciNumberGenerator f = new FibonacciNumberGenerator(tg, fibonicPos, "FibonacciNumberGenerator"); PrimeNumberGenerator p = new PrimeNumberGenerator(tg, primePos, "PrimeNumberGenerator");

PipedStreamTester mainTester = new PipedStreamTester(fibonicPis, primePis); mainTester.start(); f.start(); p.start(); } catch (IOException e) { e.printStackTrace(); } }

/* (non-Javadoc) * @see java.lang.Thread#run() */ @Override public void run() { boolean canRun = true; boolean canGoPrimeLoop = true; boolean canGoFibonicLoop = true; Long primeNumber = -1L; Long fibonacciNumber = -1L; while(canRun){ if(fibonicPis != null && canGoFibonicLoop){ try { fibonacciNumber = fibonicPis.readLong(); System.out.println(" Fibonic Number #>"+fibonacciNumber); } catch (IOException e) { //System.err.println("Exception occurred while reading from fibonacci number, "+e); canGoFibonicLoop = false; } } if(primePis != null && canGoPrimeLoop){ try { primeNumber = primePis.readLong(); System.out.println(" Prime Number #>"+primeNumber); } catch (IOException e) { //System.err.println("Exception occurred while reading from prime number, "+e); canGoPrimeLoop = false; } } } } }

import java.io.DataOutputStream; import java.io.IOException; import java.io.PipedOutputStream; public class PrimeNumberGenerator extends Thread { private DataOutputStream dos; public PrimeNumberGenerator (ThreadGroup threadGroup, PipedOutputStream pos, String name){ super(threadGroup, name); dos = new DataOutputStream(pos); } @Override public void run() { try { int x, y, c = 0; for( x = 2; x < 10000; x++ ){ if( x % 2 != 0 || x == 2 ){ for( y = 2; y <= x / 2; y++ ){ if( x % y == 0 ){ break; } } if( y > x / 2 ){ if(x < 10000){ dos.writeLong(x); dos.flush(); } } } } } catch (IOException e) { } } }

OUTPUT E:\User\Manikandan\Experiment 11>javac *.java E:\User\Manikandan\Experiment 11>java PipedStreamTester Fibonic Number #>1 Prime Number #>2 Fibonic Number #>1 Prime Number #>3 Fibonic Number #>2

Prime Number #>5 Fibonic Number #>3 Prime Number #>7 Fibonic Number #>5 Prime Number #>11 Fibonic Number #>8 Prime Number #>13 Fibonic Number #>13 Prime Number #>17 Fibonic Number #>21 Prime Number #>19 Fibonic Number #>34 Prime Number #>23 Fibonic Number #>55 Prime Number #>29 Fibonic Number #>89 Prime Number #>31 Fibonic Number #>144 Prime Number #>37 Fibonic Number #>233 Prime Number #>41 Fibonic Number #>377 Prime Number #>43 Fibonic Number #>610 Prime Number #>47 Fibonic Number #>987 Prime Number #>53 Fibonic Number #>1597 Prime Number #>59 Fibonic Number #>2584 Prime Number #>61 Fibonic Number #>4181 Prime Number #>67 Fibonic Number #>6765 Prime Number #>71 Prime Number #>73 Prime Number #>79 Prime Number #>83 Prime Number #>89 Prime Number #>97 Prime Number #>101 Prime Number #>103 Prime Number #>107 Prime Number #>109 Prime Number #>113 Prime Number #>127 Prime Number #>131 Prime Number #>137 Prime Number #>139 Prime Number #>149 Prime Number #>151 Prime Number #>157 Prime Number #>163 Prime Number #>167 Prime Number #>173

Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number Prime Number

#>179 #>181 #>191 #>193 #>197 #>199 #>211 #>223 #>227 #>229 #>233 #>239 #>241 #>251 #>257 #>263 #>269 #>271 #>277 #>281 #>283 #>293 #>307 #>311 #>313 #>317 #>331 #>337

AIM To develop a multi-threaded GUI application of your choice. ALGORITHM

SOURCE CODE

import import import import import import import

org.eclipse.swt.SWT; org.eclipse.swt.events.SelectionEvent; org.eclipse.swt.events.SelectionListener; org.eclipse.swt.graphics.Rectangle; org.eclipse.swt.widgets.Button; org.eclipse.swt.widgets.Display; org.eclipse.swt.widgets.Shell;

/** * Illustrates multithread UI programming issues. */ public class PICalculator { Display display = new Display(); Shell shell = new Shell(display); Button buttonThread = new Button(shell, SWT.PUSH); Button buttonAsyncExec = new Button(shell, SWT.PUSH); public PICalculator(boolean asyncExecEnabled) { final boolean async = asyncExecEnabled;

shell.setText("PI Calculator"); shell.setSize(400, 80); Rectangle clientArea = shell.getClientArea(); buttonThread.setText( "Click here to calculate PI [Non-UI thread UI Update]"); buttonThread.setBounds( clientArea.x, clientArea.y, clientArea.width, clientArea.height / 2); buttonThread.addSelectionListener(new SelectionListener() { public void widgetDefaultSelected(SelectionEvent e) { } public void widgetSelected(SelectionEvent e) { buttonThread.setText("Calculation in progress ..."); getTask(buttonThread).start(); } }); buttonAsyncExec.setText("Click here to calculate PI [asynExec method UI Update]"); buttonAsyncExec.setBounds( clientArea.x, clientArea.y + clientArea.height / 2, clientArea.width, clientArea.height / 2); buttonAsyncExec.addSelectionListener(new SelectionListener() { public void widgetDefaultSelected(SelectionEvent e) { } public void widgetSelected(SelectionEvent e) { buttonAsyncExec.setText("Calculation in progress ..."); getTask2(buttonAsyncExec).start(); } }); shell.open(); while (!shell.isDisposed()) { if (!display.readAndDispatch()) { display.sleep(); } } display.dispose(); } public static void main(String[] args) { // new CalculatePI(false); new PICalculator(true); } public Thread getTask(Button button) { final Button theButton = button; return new Thread() { public void run() { double pi = calculatePI(9999999); theButton.setText("PI = " + pi); // Update UI.

} }; } public Thread getTask2(Button button) { final Button theButton = button; return new Thread() { public void run() { final double pi = calculatePI(9999999); display.asyncExec(new Runnable() { public void run() { // Update UI. theButton.setText("PI = " + pi); } }); } }; } /** * Calculate value of PI using Vieta's formula. * @param nestedLevel * level of nested square roots in Vieta's formula. * @return value of PI */ public static double calculatePI(int nestedLevel) { double product = 1; double lastSqrtValue = 0; for (int i = 0; i < nestedLevel; i++) { double sqrt = getNextSqrtValue(lastSqrtValue); product *= 0.5 * sqrt; lastSqrtValue = sqrt; } return 2 / product; } /** * Return the square root item value. * * @param lastValue * last square root item value. * @return */ public static double getNextSqrtValue(double lastValue) { return Math.sqrt(2 + lastValue); } }

OUTPUT