  Java Take-Off Step Two: COMMON(LY USED) CLASSES, BASIC APPLETS

In which we're further sharpening our skills.
We start with an example of `Thread`s being used to calculate `Fibonacci` numbers.

```// Thread to calculate and print out the Fibonacci sequence of numbers
{
// the minimum time to wait before updating
private static final long WAIT_TIME = 500;

// the previous number in the sequence
private long previous;

// the current number in the sequence
private long current;

// an identifier for this sequence
private char ident;

// constructs a new Fibonacci sequence
public Fibonacci(char id)
{
// set the identifier for this sequence
ident = id;

// initialize the first two numbers in the sequence
previous = 1;
current = 1;
}

// prints the next number in the sequence
private void printNext()
{
System.out.print("(" + ident + ") " + current + ", ");
}

// calculates the next number in the sequence; it is calculated as
// the sum of the last two numbers in the sequence
private void update()
{
long temp = current;
current = previous + current;
previous = temp;
}

// execution code for the thread; this method is inherited from the
public void run()
{
// print the first two numbers in the sequence
printNext();
printNext();

// get a reference to this thread

// loop while the thread is active
while(t == this)
{
// update the sequence
update();

// once the current sequence value exceeds the largest long
// value, it will wrap around to negative values. once current
// is negative, terminate this thread of execution
if(current < 0L)
{
System.out.println("\nNo more long values! " +
t = null;
return;
}

// print out the next Fibonacci number
printNext();

// pause a bit
try
{
}

catch(InterruptedException e) { }
}
} // run
}

// creates a new Fibonacci sequence generators to test
{
public static void main(String[] args)
{
// start a few Fibonacci threads
new Fibonacci('A').start();
new Fibonacci('B').start();
new Fibonacci('C').start();
}
}``` EXERCISES
• Compile and run this program.
• Briefly describe how the program works.
• Change the program so a thread waits a random amount of time.
Let's now see a `Vector` in action.

```import java.util.*;

class VectorTest extends Object
{
public static Vector getRandomScores()
{
// create a random number generator
Random rand = new Random();

// generate between 500 and 1000 random scores
int numElements = 500 + Math.abs(rand.nextInt())%501;

// create a new Vector and fill it in with a bunch of random scores
Vector v = new Vector(numElements);
while(numElements > 0)
{
// add an Integer between 0 and 2000
numElements--;
}

return v;
}

// finds the greatest score within a vector of random scores
public static void main(String[] args)
{
int highestScore = 0;    // the highest score we've seen sofar

// generate some random scores
Vector scores = getRandomScores();

// cycle through the enumeration of the scores and pick out
// the highest one
for(Enumeration e = scores.elements(); e.hasMoreElements(); )
{
Integer score = (Integer)(e.nextElement());

if(score.intValue() > highestScore)
{
highestScore = score.intValue();
}
}

// print out the highest score
System.out.println(highestScore);
}
} // VectorTest``` EXERCISES
• Compile and run the program above.
• Briefly describe how the program works.
• When's `Random` more adequate than `Math.random()`?
There are many other classes that implement data structures.

Here's a program that uses a `HashTable` to store images.

```import java.applet.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.util.*;

public class HashTest extends Applet implements ItemListener
{
// Hashtable to add tile images
private Hashtable imageTable;

// a Choice of the various tile images
private Choice selections;

// assume tiles will have the same width and height; this represents
// both a tile's width and height
private int imageSize;

// filename description of our images
private final String[] filenames
= { "cement.gif",  "dirt.gif",  "grass.gif",
"pebbles.gif", "stone.gif", "water.gif" };

// initializes the Applet
public void init()
{
int n = filenames.length;

// create a new Hashtable with n members
imageTable = new Hashtable(n);

// create the Choice
selections = new Choice();

// create a Panel to add our choice at the bottom of the window
Panel p = new Panel();
p.setBackground(Color.lightGray);

// add the Choice to the applet and register the ItemListener

setLayout(new BorderLayout());

// allocate memory for the images and load 'em in
for(int i = 0; i < n; i++)
{
Image img = getImage(getCodeBase(), filenames[i]);
while(img.getWidth(this) < 0);

// add the image to the Hashtable and the Choice
imageTable.put(filenames[i], img);

// set the imageSize field
if(i == 0)
{
imageSize = img.getWidth(this);
}
}
} // init

// tiles the currently selected tile image within the Applet
public void paint(Graphics g)
{
// cast the sent Graphics context to get a usable Graphics2D object
Graphics2D g2d = (Graphics2D)g;

// save the Applet's width and height
int width = getSize().width;
int height = getSize().height;

// create an AffineTransform to place tile images
AffineTransform at = new AffineTransform();

// get the currently selected tile image
Image currImage = (Image)imageTable.get(selections.getSelectedItem());

// tile the image throughout the Applet
int y = 0;
while(y < height)
{
int x = 0;
while(x < width)
{
at.setToTranslation(x, y);

// draw the image
g2d.drawImage(currImage, at, this);
x += imageSize;
}
y += imageSize;
}
} // paint

// called when the tile image Choice is changed
public void itemStateChanged(ItemEvent e)
{
// our drop box has changed-- redraw the scene
repaint();
}
} // HashTest```
This program also needs an HTML file:
```<html>

<title>HashTest</title>

<body>
<hr>
<applet code=HashTest.class width=250 height=250></applet>
<hr>

</body>
</html>``` EXERCISES
• Compile and run the program above.
• Briefly describe how the program behaves.
• Make a list of the new classes and check their APIs.
Here are the images being used: cement, dirt, grass, pebbles, stone, water.

You can find the applet at:

`http://www.cs.indiana.edu/classes/a348/t540/spr2002/lectures/HashTest.html`
Use your browser, or the applet viewer, to view it.

Last updated: Apr 5, 2002 by Adrian German for `A201/A597/I210/A348/A548/T540/NC009`