FINAL EXAM CS36O

FINAL EXAM CS36O
December 16, 2010




import java.awt.Point;

import java.awt.Graphics;

import java.awt.event.MouseEvent;

import java.awt.event.MouseMotionAdapter;

import javax.swing.JPanel;

public class PaintPanel extends JPanel
{
private int pointCount = 0; //count number of points

//array of 10000 java.awt.Point references
private Point[] points = new Point[10000];

//set up GUI and register mouse event handler
public PaintPanel()
{
//handle frame mouse motion event
addMouseMotionListener(

new MouseMotionAdapter() //anonymous inner class
{
//store drag coordinates and repaint
public void mouseDragged( MouseEvent event )
{
if( pointCount < points.length )
{
points[ pointCount ] = event.getPoint(); //find point
pointCount++; //increment number of points in array
repaint(); //repaint JFrame
} //end if
} //end method mouseDragged
} //end anonymous inner class
); //end call to addMouseMotionListener
} //end PaintPanel constructor

//draw ovals in a 4-by-4 bounding box at expecified locations on window
public void paintComponent( Graphics g )
{
super.paintComponent( g ); //clears drawing area

//draw all points in array

for( int i = 0; i < pointCount; i++ )
g.fillOval( points[ i ].x, points[i].y, 4, 4 );
} //end method paintComponent
} //end class PaintPanel







import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class Painter
{
public static void main( String[] args )
{
//create JFrame
JFrame application = new JFrame( "A simple paint program." );

PaintPanel paintPanel = new PaintPanel(); //create paint panel
application.add( paintPanel, BorderLayout.CENTER); //in center

//create a label and place it in SOUTH of BorderLayout
application.add( new JLabel( "Drag the mouse to draw" ),
BorderLayout.SOUTH );

application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
application.setSize(400, 200); //set frame size
application.setVisible( true ); //display frame
} //end main
} //end class Painter

Assignment #20 CS360

Assignment #20
"Wildcard Test"
12-02-10




//WildcardTest.java

//Wildcard test program.

import java.util.ArrayList;

public class WildcardTest

{
public static void main( String[] args )

{
//create, initialize and output ArrayList of integers, then
//display total of the elements

Integer[] integers = { 1, 2, 3, 4, 5 };

ArrayList integerList = new ArrayList ();

//insert elements in intergerList
for( Integer element : integers )
integerList.add( element );

System.out.printf( "integerList contains: %s\n", integerList );
System.out.printf( "Total of the elements in integerList: %.0f\n\n",
sum( integerList ) );

//create, initialize and output ArrayList of Doubles, then
//display total of the elements
Double[] doubles = {1.1, 3.3, 5.5 };
ArrayList< Double > doubleList = new ArrayList< Double >();

//Insert Elements in doubleList
for( Double element : doubles )
doubleList.add( element );

System.out.printf( "doubleList contains:%s\n", doubleList );
System.out.printf( "Total of the elements in doubleList: %.1f\n\n",
sum( doubleList ));

//create, initialize and output ArrayList of Numbers containing
//both Integers and Doubles, then display total of the elements
Number[] numbers = {1, 2.4, 3, 4.1 }; //Integers and Doubles
ArrayList< Number > numberList = new ArrayList< Number >();

//Insert elements in numberList
for( Number element : numbers )
numberList.add( element );

System.out.printf( "numberList contains: %s\n", numberList );
System.out.printf( "Total of the elements in numberList: %.1f\n",
sum( numberList));

}//end main

//total the elements; using a wildcard in the ArrayList parameter
public static double sum( ArrayList< ? extends Number > list )
{
double total = 0; //initialize total

//calculate sum
for( Number element : list )
total += element.doubleValue();

return total;

}//end method sum
}//end class WildcardTest

Assignment #18 CS360

Assignment #18
"MenuFrame & MenuTest"
11-11-10







// Fig. 22.5: Menu Frame.java
// Demostrating menus.

import java.awt.Color;
import java.awt.Font;
import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
import javax.swing.JFrame;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.ButtonGroup;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JMenuBar;

public class MenuFrame extends JFrame
{
private final Color colorValues[] =
{ Color.BLACK, Color.BLUE, Color.RED, Color.GREEN };
private JRadioButtonMenuItem colorItems[]; //color menu items
private JRadioButtonMenuItem fonts[]; //font menu items
private JCheckBoxMenuItem styleItems[]; //font style menu items
private JLabel displayJLabel; //displays sample text
private ButtonGroup fontButtonGroup; //manages font menu items
private ButtonGroup colorButtonGroup; //manages color menu items
private int style; //used to create style for font

//no-argument constructor set up GUI
public MenuFrame()
{
super(" Usiing JMenus" );

JMenu fileMenu = new JMenu( "File" ); //create file menu
fileMenu.setMnemonic( 'F' ); //set mnemonic to F

// Create About... menu item
JMenuItem aboutItem = new JMenuItem( "About..." );
aboutItem.setMnemonic( 'A' ); //set mnemonic to A
fileMenu.add( aboutItem ); //add about item to file menu
aboutItem.addActionListener(

new ActionListener() //anonymous inner class
{
//display message dialog when user selects About...
public void actionPerformed( ActionEvent event )
{
JOptionPane.showMessageDialog( MenuFrame.this,
"This is an example\not using menus",
"About", JOptionPane.PLAIN_MESSAGE );
} //End method actionPerformed
} //End anonimous inner class
); //end call to addActionListener

JMenuItem exitItem = new JMenuItem( "Exit" ); //create exit item
exitItem.setMnemonic( 'x' ); //set mnemonic to x
fileMenu.add( exitItem ); // add exit item to file menu
exitItem.addActionListener(

new ActionListener() // anonymous inner class
{
//terminate application when user clicks exitItem
public void actionPerformed( ActionEvent event )
{
System.exit( 0 ); //exit application
} // end method actionPerformed
} //end anonymous inner class
); //end call to addActionListener

JMenuBar bar = new JMenuBar(); //create menu bar
setJMenuBar( bar ); //add menu bar to application
bar.add( fileMenu ); //add file menu to menu bar

JMenu formatMenu = new JMenu( "Format" ); //create format menu
formatMenu.setMnemonic( 'r' ); //set mnemonic to r

//array listing string colors
String colors[] = { "Black", "Blue", "Red", "Green" };

JMenu colorMenu = new JMenu( "Color" ); //create color menu
formatMenu.setMnemonic( 'C' ); //set mnemonic to C

//create radio button menu items for colors
colorItems = new JRadioButtonMenuItem[ colors.length ];
colorButtonGroup = new ButtonGroup(); //manages colors
ItemHandler itemHandler = new ItemHandler(); // handler for colors

//create color radio button menu items
for( int count = 0; count < colors.length; count++ )
{
colorItems[ count ] =
new JRadioButtonMenuItem( colors[ count ] );//create item
colorMenu.add( colorItems[ count ]); //add item to color menu
colorButtonGroup.add( colorItems[ count ] ); // add to group
colorItems[ count ].addActionListener( itemHandler );
} //end for

colorItems[ 0 ].setSelected( true ); //select first Color Item

formatMenu.add( colorMenu ); //add color menu to format menu
formatMenu.addSeparator(); //add separator in menu

//array listing font names
String fontNames[] = { "Serif", "Monospace", "SansSerif" };
JMenu fontMenu = new JMenu( "Font" ); //create font menu
fontMenu.setMnemonic( 'n' ); //set mnemonic to n

//create radio button menu items for font names
fonts = new JRadioButtonMenuItem[ fontNames.length ];
fontButtonGroup = new ButtonGroup(); //manages font names

//create Font radio button menu items
for( int count = 0; count < fonts.length; count++ )
{
fonts[ count ] = new JRadioButtonMenuItem( fontNames[ count ] );
fontMenu.add( fonts[ count ] ); //add font to menu font
fontButtonGroup.add( fonts[ count ] ); //add to button groupt
fonts[ count ].addActionListener( itemHandler ); //add handler
} //end for

fonts[ 0 ].setSelected( true ); //select first Font menu item
fontMenu.addSeparator(); //add separator bar to font menu

String styleNames[] = {"Bold", "Italic" }; // names of styles
styleItems = new JCheckBoxMenuItem[styleNames.length ];
StyleHandler styleHandler = new StyleHandler(); //style handler

//create style checkbox menu items
for( int count = 0; count < styleNames.length; count++ )
{
styleItems[ count ]=
new JCheckBoxMenuItem( styleNames[ count ] ); //for style
fontMenu.add( styleItems[ count ] ); //add to font menu
styleItems[ count ].addItemListener( styleHandler ); //handler
} //end for

formatMenu.add( fontMenu ); //add Font menu to Format menu
bar.add( formatMenu ); // add Format menu to menu bar

// set up label to display text
displayJLabel = new JLabel( "Sample Text", SwingConstants.CENTER );
displayJLabel.setForeground( colorValues[ 0 ] );
displayJLabel.setFont( new Font( "Serif", Font.PLAIN, 72) );

getContentPane().setBackground( Color.CYAN ); // set background
add( displayJLabel, BorderLayout.CENTER ); // add displayLabel
} //end MenuFrame constructor

//inner class to handle action events from menu items
private class ItemHandler implements ActionListener
{
//process color and font selections
public void actionPerformed( ActionEvent event )
{
//process color selection
for( int count = 0; count < colorItems.length; count++ )
{
if( colorItems[ count ].isSelected() )
{
displayJLabel.setForeground( colorValues[ count ] );
break;
} //end if
} //end for

//process font selection
for( int count = 0; count < fonts.length; count++ )
{
if( event.getSource() == fonts[ count ] )
{
displayJLabel.setFont(
new Font( fonts[ count ].getText(), style, 72 ));
} // end if
} //end for

repaint(); //redray application
} //end method ActionPerformed
} //end class ItemHandler

//inner class to handle item events for check box menu items
private class StyleHandler implements ItemListener
{
//process font style selections
public void itemStateChanged( ItemEvent e )
{
style = 0; //initialize style

//check for bold selection
if( styleItems[ 0 ].isSelected() )
style += Font.BOLD; //add bold to style

//check for italic selection
if( styleItems[ 1 ].isSelected() )
style += Font.ITALIC; //add italic to style

displayJLabel.setFont(
new Font( displayJLabel.getFont().getName(), style, 72 ));
repaint(); //redraw application
} //end method itemStateChanged
} //end class StyleHandler
} //end class MenuFrame


_____________________________________________________________

// Fig. 22.6: MenuTest.java
// Testing MenuFrame.

import javax.swing.JFrame;

public class MenuTest
{
public static void main( String args[] )
{
MenuFrame menuFrame = new MenuFrame(); // create MenuFrame
menuFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
menuFrame.setSize( 500, 200 ); //set frame size
menuFrame.setVisible( true ); //display frame
} //end main
} //end class MenuTest

Assignment #17 CS360

Assignment #17
"OvalPanel, SliderFrame & SliderTest"
11-04-10






/*
//Graphics problem
*/
import java.awt.Graphics;
import java.awt.Dimension;
import javax.swing.JPanel;

public class OvalPanel extends JPanel
{
private int diameter = 10;//default diameter of 10

//draw an oval of the specified diameter
public void paintComponent( Graphics g )
{
super.paintComponent( g );

g.fillOval( 10, 10, diameter, diameter ); //draw circle
}

//validate and set diameter
public void setDiameter( int newDiameter )
{
//if diameter invalid, default to 10
diameter = ( newDiameter >= 0 ? newDiameter : 10 );
repaint(); //repaint panel
}

//use by layout manager to determine preffered size
public Dimension getPreferredSize()
{
return new Dimension( 200, 200 );
}

//used by layout manager to determine minimum size
public Dimension getMinimumSize()
{
return getPreferredSize();
}
}

__________________________________________________________________________


/*
//SliderFrame
*/
import java.awt.BorderLayout;
import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JSlider;
import javax.swing.SwingConstants;
import javax.swing.event.ChangeListener;
import javax.swing.event.ChangeEvent;

public class SliderFrame extends JFrame
{
private JSlider diameterJSlider; // slider to select diameter
private OvalPanel myPanel; // panel to draw circle

//no argument constructor
public SliderFrame()
{
super( "Slider Demo" );

myPanel = new OvalPanel(); //create panel to draw circle
myPanel.setBackground( Color.YELLOW ); //set bacground to yellow

//set up JSlider to control diameter value
diameterJSlider = new JSlider( SwingConstants.HORIZONTAL, 0 , 200, 10 );
diameterJSlider.setMajorTickSpacing(10); //create tick every 10
diameterJSlider.setPaintTicks( true ); //paint ticks on slider

//register JSlider event listener
diameterJSlider.addChangeListener(

new ChangeListener() //anonymous inner circle
{
//handle change in slider value
public void stateChanged( ChangeEvent e )
{
myPanel.setDiameter( diameterJSlider.getValue() );
}
}
);

add( diameterJSlider, BorderLayout.SOUTH ); //add slider to frame
add( myPanel, BorderLayout.CENTER ); //add panel to frame
}
}

__________________________________________________________________________

/*
//main method
*/

import javax.swing.JFrame;

public class SliderDemo
{
public static void main( String args[] )
{
SliderFrame sliderFrame = new SliderFrame();
sliderFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
sliderFrame.setSize( 220, 270 ); //set frame size
sliderFrame.setVisible( true ); //display frame
}
}

Assignment #14 CS360

Assignment #1
"Merge Sort & Merge Sort Test"
10-21-10









/*

//Merge Sort

*/

import java.util.Random;

public class MergeSort
{
private int[] data; //array of values
private static Random generator = new Random();

//create array of given size and fill with random integers
public MergeSort( int size )
{
data = new int[size]; //create space for array

//fill array with random ints range 10-99
for( int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt( 90 );
}

//calls recursive split method to begin merge sorting
public void sort()
{
sortArray( 0, data.length - 1); //split entire array
}

//splits array, sort subarrays and merges subarrays into sorted array
private void sortArray( int low, int high )
{
//test case: size of array equals 1
if( ( high - low ) >= 1 ) //if not base case
{
int middle1 = (low + high )/2; //calculate middle of array
int middle2 = middle1 + 1; //calculate next element over

//output split step
System.out.println( "split: " + subarray( low, high ) );
System.out.println( " " + subarray( low, middle1 ) );
System.out.println( " " + subarray( middle2, high ) );

//split array in half; sort each half of array
sortArray( low, middle1 ); //first half of array
sortArray( middle2, high ); //second half of array

//merge 2 sorted arrays after split calls return
merge( low, middle1, middle2, high );
}
}

//merge 2 sorted subarrays into one sorted sub array
private void merge( int left, int middle1, int middle2, int right )
{
int leftIndex = left; //index into left subarray
int rightIndex = middle2; //index into right subarray
int combinedIndex = left; //index into temp. work array
int[] combined = new int[data.length]; //working array

//output 2 subarrays before merging
System.out.println( "merge: " + subarray( left, middle1 ) );
System.out.println( " " + subarray( middle2, right ) );

//merge arrays until reaching end of either
while( leftIndex <= middle1 && rightIndex <= right )
{
//place smaller of 2 current elements into result
//and move to next space in arrays
if( data[leftIndex] <= data[rightIndex] )
combined[combinedIndex++] = data[leftIndex++];
else
combined[combinedIndex++] = data[rightIndex++];
}

//if array is empty
if( leftIndex == middle2 )
//copy in rest of right array
while( rightIndex <= right )
combined[combinedIndex++] = data[rightIndex++];
else
//copy in rest of left array
while( leftIndex <= middle1 )
combined[combinedIndex++] = data[leftIndex++];

//copy values back into original array
for( int i = left; i <= right; i++ )
data[i] = combined[i];

//output merged array
System.out.println(" " + subarray( left, right ) );
System.out.println();

}

//method to output certain values in array
public String subarray( int low, int high )
{
StringBuilder temporary = new StringBuilder();

//output spaces for alignment
for( int i = 0; i < low; i++ )
temporary.append( "" );

//output elements left in array
for( int i = low; i <= high; i++ )
temporary.append( "" + data[i] );

return temporary.toString();
}

//method to output values in array
public String toString()
{
return subarray( 0, data.length - 1 );
}
}






/*

//main function

*/

public class MergeSortTest
{
public static void main( String[] args )
{
//create object to perform merge sort
MergeSort sortArray = new MergeSort(10);

//print unsorted array
System.out.println( "Unsorted: " + sortArray + "\n" );

sortArray.sort(); //sort array

//print sorted array
System.out.println( "Sorted: " + sortArray );
}
}

Assignment #13 CS360

Assignment #13
"Insertion Sort & Insertion Sort Test"
10-21-10






/*

//Insertion Sort
*/

import java.util.Random;

public class InsertionSort
{
private int[] data; //array of values
private static Random generator = new Random();

//create array of given size to fill
public InsertionSort( int size)
{
data = new int[size]; //create space for arrays

//fill arrays with random numbers 10-99
for( int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt(90);
}

//sort array using insertion sort
public void sort()
{
int insert; //temp; variable to hold element to insert

//loop over data.length - elements
for( int next = 1; next < data.length; next++ )
{
//sort value in current element
insert = data[next];

//initialize location to place element
int moveItem = next;

//search for place to put current element
while( moveItem > 0 && data[moveItem - 1] > insert )
{
//shift element right one slot
data[moveItem] = data[moveItem - 1];
moveItem--;
}

data[moveItem] = insert; //place inserted element
printPass( next, moveItem ); //output pass of algorithm
}
}

//print a pass of the algorithm
public void printPass( int pass, int index )
{
System.out.print( String.format( "after pass %2d:", pass ) );

//output elements till swapped item
for(int i = index + 1; i < data.length; i++ )
System.out.print( data[i] + "");

System.out.print( "\n "); //for allignment

//indicate amount of array that is sorted
for( int i = 0; i <= pass; i++ )
System.out.print( "--" );
System.out.println( "\n" ); //add endline
}

//method to output values in array
public String toString()
{
StringBuilder temporary = new StringBuilder();

//iterate through array
for( int element : data )
temporary.append( element + "" );

temporary.append( "\n" ); //add endline character
return temporary.toString();
}
}





/*

//main function

*/

public class InsertionSortTest
{
public static void main( String[] args )
{
//create object to perform insertion sort
InsertionSort sortArray = new InsertionSort( 10 );

System.out.println( "Unsorted array:" );
System.out.println( sortArray ); //print unsorted array

sortArray.sort();

System.out.println( "Sorted array: ");
System.out.println( sortArray ); //print sorted array
}
}

Assignment #12 CS360

Assignment #12
"Selection Sort & Selection Sort Test"
10-14-10





/*

//Selection Sort Algorithm
*/

import java.util.Random;

public class SelectionSort
{
private int[] data; //array of value
private static Random generator = new Random();

//create array if given size and fill w/ random int
public SelectionSort( int size )
{
data = new int[size]; //create space for array

//fill array with random int 10-99
for(int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt( 90 );
}

//sort array using slection sort
public void sort()
{
int smallest; //index of smallest element

//loop over data length -1
for(int i = 0; i < data.length - 1; i++)
{
smallest = i; //first index of remaining array

//loops to find index of smallest element
for( int index = i + 1; index < data.length; index++)
if(data[index] < data[smallest])
smallest = index;

swap( i, smallest); //swap smallest elements into position
printPass( i + 1, smallest );
}
}

//helper method to swap values in two elements
public void swap( int first, int second )
{
int temporary = data[first]; //store first in temporary
data[first] = data[second]; //replace first with second
data[second] = temporary; //put temporary in second
}

//print a pass of algorigthm
public void printPass( int pass, int index )
{
System.out.print( String.format( "after pass %2d; ", pass) );

//output elements till selectem item
for (int i = 0; i < index; i++)
System.out.print( data[i] + "");

System.out.print( "\n "); //for alignment

//indicate amount of array that is sorted
for( int j = 0; j < pass; j++ )
System.out.println("\n"); //add endline
}

//method to output balues in array
public String toString()
{
StringBuilder temporary = new StringBuilder();

//iterate through array
for( int element : data)
temporary.append( element + " " );

temporary.append("\n");
return temporary.toString();
}
}

~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|~|

/*

//main function
*/

public class SelectionSortTest
{
public static void main( String[] args )
{
//create object to perform selection sort
SelectionSort sortArray = new SelectionSort(10);

System.out.println( "Unsorted array:" );
System.out.println( sortArray ); //print unsorted array

sortArray.sort(); //sort array

System.out.println( "Sorted Array:" );
System.out.println( sortArray ); //print sorted array
}
}