Final - Painter

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.awet.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[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 addMouseMotion Listener
}//end PaintPanel constructor

//draw ovals in a 4 by 4 bounding box at specified locations on window

public void paintComponent(Graphics g)

{
super.paintComponent(g); //clears drawing area

//draw all points in array

for (int i=0; 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 border layout

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

Wildcard Test

//wildcardTest.java

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};

ArrayListintegerList=new ArrayList();

//insert elements in interger list

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};

ArrayListdoubleList=new ArrayList();

//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

ArrayListnumberList=new ArrayList();

//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(ArrayListlist)

{
double total=0; //initialize total

//calculate sum

for (Number element:list)

total +=element.doubleValue();

return total;

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

Assignment 19 - Deck Of Cards

// Deck of Cards
//Card shuffling and dealing with collections method shuffle.

import java.util.List;
import java.util.Arrays;
import java.util.Collections;

//class to represent a Card in a deck of cards
class Card
{
public static enum Face { Ace, Deuce, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King };
public static enum Suit { Clubs, Diamonds, Hearts, Spades };

private final Face face; //face of card
private final Suit suit; //Suit of card

//two-argument constructor

public Card( Face cardFace, Suit cardSuit )
{
face = cardFace; //initialize face of card
suit = cardSuit; //initialize face of card
} //end two-argument card constructor

//return face of the card

public Face getFace()
{
return face;
} // end method getFace

//return suit of card

public Suit getSuit()
{
return suit;
} //end method getSuit

//return string representation of card

public String toString()
{
return String.format("%s of %s", face, suit );
} //end method toString
}//end class card

//class DeckofCards declaration

public class DeckOfCards
{
private List<> list; //declare List that will store cards

//set up deck of cards and shuffle
public DeckOfCards()
{
Card[] deck = new Card [ 52 ];
int count = 0; //number of cards

//populate deck with Card Objects

for ( Card.Suit suit : Card.Suit.values() )
{
for ( Card.Face face : Card.Face.values() )
{
deck[ count ] = new Card( face, suit );
++count;
} //end for
}//end for

list = Arrays.asList( deck ); // get list
Collections.shuffle( list ); //shuffle deck
} //end of DeckOfCards constructor

// output deck

public void printCards()
{
//display 52 cards in two colums

for ( int i = 0; i System.out.printf( "%-19s%s", list.get( i ),
( ( i+1 ) %4 == 0 ) ? "\n" : "");
} //end method print cards

public static void main( String[] args )
{
DeckOfCards cards = new DeckOfCards();
cards.printCards();
}//end main
}//end class DeckOfCards

Assignment 17: Slider Demo

/*
//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 18 - Menu Test

// Fig. 22.5: MenuFrame.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("Using Menus");

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() //anonuymous inner class
{
//displays message dialog when the user selects About...
public void actionPerformed(ActionEvent event)
{
JOptionPane.showMessageDialog(MenuFrame.this,
"This is an example\nof using menus",
"About",JOptionPane.PLAIN_MESSAGE);
}//end method actionPerformed
}//end anonymous 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
colorMenu.setMnemonic('C'); //set mnenonic 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{
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","Monospaced","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[ count ] = new JRadioButtonMenuItem(fontNames[count]);
fontMenu.add(fonts[count]); //add font to font menu
fontButtonGroup.add(fonts[count]); //add to button group
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{
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 displayJLabel
}//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 {
if (colorItems[count].isSelected())
{
displayJLabel.setForeground(colorValues[ count]);
break;
}//end if
}//end for

//process font selection

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

repaint(); //redraw application
}//end method actionPerformed
}//end class ItemHandler

// inner class to handle item events from chech 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[1].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.65 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

MIDTERM - InsertionSortTest

/*

Insertion Sort Midterm
*/

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 MIDTERM
*/
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 14 - Merge Sort Test

/*

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 - Insertion Sort Test

/*
Assignment 13
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 palce 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();
}
}


---------------------------------------------------------------------------------


/*
Assignment 13
main function
*/
public class InsertionSortTest
{
public static void main( String[] args )
{
//create object to preform 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 - Selection Sort Test

/*
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
}
}

Towers of Hanoi

/* Towers of Hanoi */

public class TowersOfHanoi
{
private int numDisks; //number of disks to move

public TowersOfHanoi( int disks )
{
numDisks = disks;
}

//recursively more disks between towers
public void solveTowers(int disks, int sourcePeg, int destinationPeg, int tempPeg)
{

//base case -- only one disk to move

if( disks == 1)
{
System.out.printf("\n%d --> %d",sourcePeg, destinationPeg);
return;
}

//recursion step -- move (disk -1) disk from sourcePeg
//to tempPEg using destinationPeg

solveTowers(disks-1,sourcePeg,tempPeg,destinationPeg);

//move last disk from sourcePeg to destinationPeg

System.out.printf("\n%d --> %d", sourcePeg, destinationPeg);

//move (disk-1) disk from tempPeg to destinationPeg

solveTowers( disks - 1, tempPeg, destinationPeg, sourcePeg);
}
}

--------------------------------------------------------------------


/* Main function to be run */

public class TowersOfHanoiTest

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

int startPeg = 1; // value 1 used to indicate startPeg in output
int endPeg = 3; // value 3 usedto indicate endPeg in output
int tempPeg = 2; // value 2 used to indicate tempPeg output
int totalDisks = 3; // number of disks

TowersOfHanoi towersOfHanoi = new TowersOfHanoi(totalDisks);

//initial nonrecursive call: move all disks

towersOfHanoi.solveTowers(totalDisks, startPeg, endPeg, tempPeg);
}
}

Binary Search Test

/*
Assignment #
*/

import java.util.Random;
import java.util.Arrays;

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

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

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

Arrays.sort( data );
}

//preform binary search in data
public int binarySearch( int searchElement )
{
int low = 0; //low end of search area
int high = data.length - 1; //high end of search area
int middle = (low + high + 1)/2; //middle element
int location = -1; //retunr value; -1 if not found

do //loop to search element
{
//print remaining elements of array
System.out.print( remainingElements( low, high ) );

//output spaces for alignment
for(int i=0; i
System.out.print( " " );
System.out.println( " * " ); //indicate current middle

//if the element is found at the middle
if(searchElement == data[ middle ])
location = middle; //location is the current middle

//middle element is too high
else if(searchElement
high = middle - 1; //eliminate the higher half
else //middle element too low
low = middle + 1; //eliminate the lower half

middle = (low + high + 1)/2; //recalculate the middle
}

while( (low <= high) && (location == -1) );

return location; //return location of search key
}

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

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

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

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

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

-------------------------------------------------------------------

import java.util.Scanner;

public class BinarySearchTest
{
public static void main( String args[] )
{
// create Scanner object to input data
Scanner input = new Scanner( System.in );

int searchInt; //search key
int position; //location of search key in array

//create array and output it
BinaryArray searchArray = new BinaryArray( 15 );
System.out.println( searchArray );

//get input from user
System.out.print( "Please enter an integer value (-1 to quit): ");
searchInt = input.nextInt(); //read an int from user
System.out.println();

//repeadtedly ubput an integer; -1 terminates the program
while(searchInt != -1)
{
//use binary search to try to find integer
position = searchArray.binarySearch( searchInt );

//return value of -1 indicates indicates integer was not found
if(position == -1)
System.out.println( "The integer " + searchInt + " was not found.\n" );

else
System.out.println( "The integer " + searchInt + " was found in position "
+ position + ".\n" );

//get input from user
System.out.print( "Please enter an integer value (-1 to quit): " );
searchInt = input.nextInt(); //read an int from user
System.out.println();
}
}
}

Fibonacci Calculator & Fibonacci Test

/* Fibonacci Calculator*/

public class FibonacciCalculator
{
//reverse declaration of method Fibonacci
public long fibonacci( long number )
{
if((number ==0)||(number ==1)) //base cases
return number;
else //recursion step
return fibonacci( number-1) + fibonacci(number-2);
}

public void displayFibonacci()
{
for (int counter=0; counter<=10; counter++)
System.out.printf("Fibonacci of %d is %d\n", counter, fibonacci(counter)
);
}
}

------------------------------------------------

/*Fibonacci Test */
public class FibonacciTest
{
public static void main(String args[])
{
FibonacciCalculator fibonacciCalculator=new FibonacciCalculator();
fibonacciCalculator.displayFibonacci();
}
}

Factorial Calculator & Factorial Test

/* Factorial Calculator */

public class FactorialCalculator
{
//recursive declaration on method factorial

public long factorial(long number)
{
if(number <=1) // test for base case
return 1; //base cases: 0!=1 and 1!=1
else //recursion step
return number*factorial(number-1);
}

//output factorials for values 0-10
public void displayFactorials()
{
//calculate factorials of 0 through 10
for(int counter=0; counter<=10; counter++)
System.out.printf("%d!= %d\n", counter, factorial(counter));
}
}

-----------------------------

/* Factorial Test*/

public class FactorialTest
{
//calculate factorials of 0 - 10

public static void main( String args[])
{
FactorialCalculator factorialCalculator=new FactorialCalculator();
factorialCalculator.displayFactorials();
}
}

Assignment # 7 LinearSearchTest

/* LinearArray */

import java.util.Random;

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

// Create array of any size and fill with random int
public LinearArray( int size)
{
data = new int[size]; //creates spaces for array

//fills array with ints 10-99

for(int i=0; i
data[i] = 10 + generator.nextInt(90);
}

//perform a linear search on the data
public int linearSearch( int searchKey )
{
//loop thourgh array sequentionally
for (int index=0; index
if( data[index] == searchKey)
return index; //return inex int

return -1; //integer not found
}
//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
return temporary.toString();
}
}


---------------------------------------------------------------

/*LinearSearchTest*/

import java.util.Scanner;

public class LinearSearchTest
{
public static void main( String args[])
{
// create Scanner object to input data
Scanner input = new Scanner( System.in );

int searchInt; // search key
int position; // location of search key in array

// create array and output it

LinearArray searchArray = new LinearArray( 10 );
System.out.println( searchArray ); // print array

// get input from user
System.out.print(
"Please enter an integer value (-1 to quit): " );
searchInt = input.nextInt(); // read first int from user

// repeatedly input an integer; -1 terminates the program
while ( searchInt != -1 )
{
// perform linear search
position = searchArray.linearSearch( searchInt );

if ( position == -1 ) // integer was not found
System.out.println( "The integer " + searchInt +
" was not found.\n" );


// get input from user

System.out.print(
"Please enter an integer value (-1 to quit): " );
searchInt = input.nextInt(); // read next int from user
}
}
}

Assignment #6 Label Frame & Label Test

/*
Assignment 6 Gabriel Cuevas
*/

import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.Icon;
import javax.swing.ImageIcon;

public class LabelFrame extends JFrame
{
private JLabel label1; //Just for text
private JLabel label2; //Constructed with text and icon
private JLabel label3; // with added text and icon

public LabelFrame()
{
super( "Testing JLabel" );
setLayout (new FlowLayout() );

//JLabel constructor with string argument
label1 = new JLabel( "Label with text" );
label1.setToolTipText( "This is label1" );
add( label1);

//JLabel constructor with string, Icon and alignment arguments
Icon bug = new ImageIcon( getClass().getResource( "bug1.jpg" ) );
label2 = new JLabel( "Label with text and icon", bug,
SwingConstants.LEFT);
label2.setToolTipText( "This is label2" );
add( label2 );

//JLabel constructor with no arguments
label3 = new JLabel();
label3.setText( "Label with icon and text at bottom" );
label3.setIcon( bug );
label3.setHorizontalTextPosition( SwingConstants.CENTER);
label3.setVerticalTextPosition( SwingConstants.BOTTOM);
label3.setToolTipText( "This is label3" );
add( label3 );
}
}

SECOND PART

/*
Assignment 6 Main Function Gabriel Cuevas
*/

import javax.swing.JFrame;

public class LabelTest
{
public static void main( String args[] )
{
LabelFrame labelFrame = new LabelFrame(); //creates LabelFrame
labelFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE);
labelFrame.setSize(275, 180 );
labelFrame.setVisible( true );
}
}

Assignment #5 AverageCarFuel.java

/* assignment 5*/

import javax.swing.JOptionPane;

public class AverageCarFuel
{
public static void main( String args[] )
{
String milesTravled = JOptionPane.showInputDialog( "Enter number of miles traveled" );
String gallonsUsed = JOptionPane.showInputDialog( "Enter gallons used" );

double miles = Integer.parseInt( milesTravled );
double gallons = Integer.parseInt( gallonsUsed );

//gac = gas average for car

double gac = miles / gallons;

JOptionPane.showMessageDialog( null, "Your gas average is " + gac, "Your Gas Average", JOptionPane.PLAIN_MESSAGE);

}
}

Assignment #4 Addition.java

//Assignment 4 Addition.java


import javax.swing.JOptionPane;

public class Addition
{
public static void main(String args[] )
{
//obtain user input from JOptionPaneinput dialogs
String firstNumber =
JOptionPane.showInputDialog( "Enter first interger" ) ;
String secondNumber =
JOptionPane.showInputDialog( "Enter second integer" ) ;

//convert string into int values
int number1 = Integer.parseInt( firstNumber ) ;
int number2 = Integer.parseInt( secondNumber ) ;

int sum = number1 + number2;

//display results in JOptionPane mssg dialog
JOptionPane.showMessageDialog( null, "The sum is " + sum,
"Sum of Two Integers", JOptionPane.PLAIN_MESSAGE) ;
}
}

Assignment #3 Shapes

/* Assignment 3 */

//Shapes.java
//Demostrates drawing different shapes.
import java.awt.Graphics;
import javax.swing.JPanel;

public class Shapes extends JPanel
{
private int choice; //user's choice of which shape to draw

//constructor sets the user's choice
public Shapes(int userChoice)
{
choice = userChoice;
} //end Shapes constructor

// draws a cascade of shapes starting from the top-left corner
public void paintComponent(Graphics g)
{
super.paintComponent(g);
for ( int i = 0; i < 10; i++)
{
//pick the shape based on the user's choice
switch (choice)
{
case 1: //draw rectangles
g.drawRect(10 + i * 10, 10 + i * 10, 50 + i * 10, 50 + i * 10 );
break;
case 2: //draw ovals
g.drawOval(10 + i * 10, 10 + i * 10, 50 + i * 10, 50 + i * 10 );
break;
} // end switch
} // end for
} // end method paintCompnent
} //end class Shapes

----------------------------------------------------------------------------


/*

Test for Shapes

*/

import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class ShapesTest
{
public static void main ( String args[])
{
//obtain user's choice

String input = JOptionPane.showInputDialog(
"Enter 1 to draw rectangles\n"+
"Enter 2 to draw ovals");

int choice=Integer.parseInt( input ); //converts input to int

//create the panel with the user's input
Shapes panel = new Shapes(choice);

JFrame application = new JFrame(); // creates new JFrame

application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
application.add(panel);
application.setSize(300,300);
application.setVisible(true);
}
}

Assignment #2 - ArrayOnFrame

/*
Assignment 2
*/

import javax.swing.*;

public class ArrayOnFrame
{

private static void createAndShowGUI()
{
int[]anArray;

anArray = new int[10];

anArray[0] = 100;
anArray[1] = 200;
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;

JFrame frame = new JFrame("ArrayOnFrame");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JLabel label = new JLabel("element at index0:" + anArray[0] );
frame.getContentPane().add(label);

frame.pack();
frame.setVisible(true);
}

public static void main(String[] args)
{
javax.swing.SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
createAndShowGUI();
}
});
}
}

Assignment #1 Hello World

/*
Assignment 1 HelloWorldSwing
*/
/*
*HelloWorldSwing.java required no other files.
*/
import javax.swing.*;

public class HelloWorldSwing {
/**
*Create the GUI and show it.
*/
private static void createAndShowGUI () {
//Create and set up the window.
JFrame frame = new JFrame ("HelloWorldSwing");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Add the ubiquitous " Hello World" label.
JLabel label = new JLabel("Hello Gabriel");
frame.getContentPane().add(label);

//Display the window.
frame.pack();
frame.setVisible(true);
}

public static void main (String[] args) {
//Schedule a job for the event-displacing thread:
//creating and showing this application's GUI.
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
createAndShowGUI ();
}
});
}
}