## Cambios en el JDK 1.1:
El applet Sorting

SortItem.java, que forma parte del applet Sorting, utiliza un API caducado del AWT y debería ser re-escrito para utilizarse con el JDK 1.1. Primero, utiliza dos métodos caducados del AWT: los métodos size y resize que han sido renombrados como getSize y setSize, respectivamente. Segundo, utiliza el viejo mecanismo de manejo de eventos (sobreescribe mouseUp).

Aquí tienes la versión para el JDK 1.1. de SortItem.java utilizando los nuevos nombres de métodos y el nuevo mecanismo de manejo de eventos:

>     import java.awt.*;
>     import java.awt.event.MouseAdapter;
>     import java.awt.event.MouseEvent;

>     import java.io.InputStream;
>     import java.util.Hashtable;
>     import java.net.*;

>     /**
>      * A simple applet class to demonstrate a sort algorithm.
>      * You can specify a sorting algorithm using the "alg"
>      * attribute. When you click on the applet, a thread is
>      * forked which animates the sorting algorithm.
>      *
>      * @author James Gosling
>      * @version 	1.17f, 10 Apr 1995
>      */
>     public class SortItem1_1 extends java.applet.Applet implements Runnable {
>         /**
>          * The thread that is sorting (or null).
>          */
>         private Thread kicker;

>         /**
>          * The array that is being sorted.
>          */
>         int[] arr;

>         /**
>          * The high water mark.
>          */
>         int h1 = -1;

>         /**
>          * The low water mark.
>          */
>         int h2 = -1;

>         /**
>          * The name of the algorithm.
>          */
>         String algName;

>         /**
>          * The sorting algorithm (or null).
>          */
>         SortAlgorithm algorithm;

>         /**
>          * Fill the array with random numbers from 0..n-1.
>          */
>         void scramble() {
>     	int[] a = new int[getSize().height / 2];
>     	double f = getSize().width / (double) a.length;
>     	for (int i = a.length; --i >= 0;) {
>     	    a[i] = (int)(i * f);
>     	}
>     	for (int i = a.length; --i >= 0;) {
>     	    int j = (int)(i * Math.random());
>     	    int t = a[i];
>     	    a[i] = a[j];
>     	    a[j] = t;
>     	}
>     	arr = a;
>         }

>         /**
>          * Pause a while.
>          * @see SortAlgorithm
>          */
>         void pause() {
>     	pause(-1, -1);
>         }

>         /**
>          * Pause a while, and draw the high water mark.
>          * @see SortAlgorithm
>          */
>         void pause(int H1) {
>     	pause(H1, -1);
>         }

>         /**
>          * Pause a while, and draw the low&high water marks.
>          * @see SortAlgorithm
>          */
>         void pause(int H1, int H2) {
>     	h1 = H1;
>     	h2 = H2;
>     	if (kicker != null) {
>     	    repaint();
>     	}
>     	try {Thread.sleep(20);} catch (InterruptedException e){}
>         }

>         /**
>          * Initialize the applet.
>          */
>         public void init() {
>     	String at = getParameter("alg");
>     	if (at == null) {
>     	    at = "BubbleSort";
>     	}

>     	algName = at + "Algorithm";
>     	scramble();

>     	setSize(100, 100);
>             addMouseListener(new MyAdapter());
>         }

>         /**
>          * Paint the array of numbers as a list
>          * of horizontal lines of varying lenghts.
>          */
>         public void paint(Graphics g) {
>     	int[] a = arr;
>     	int y = getSize().height - 1;

>     	// Erase old lines
>     	g.setColor(Color.lightGray);
>     	for (int i = a.length; --i >= 0; y -= 2) {
>     	    g.drawLine(arr[i], y, getSize().width, y);
>     	}

>     	// Draw new lines
>     	g.setColor(Color.black);
>     	y = getSize().height - 1;
>     	for (int i = a.length; --i >= 0; y -= 2) {
>     	    g.drawLine(0, y, arr[i], y);
>     	}

>     	if (h1 >= 0) {
>     	    g.setColor(Color.red);
>     	    y = h1 * 2 + 1;
>     	    g.drawLine(0, y, getSize().width, y);
>     	}
>     	if (h2 >= 0) {
>     	    g.setColor(Color.blue);
>     	    y = h2 * 2 + 1;
>     	    g.drawLine(0, y, getSize().width, y);
>     	}
>         }

>         /**
>          * Update without erasing the background.
>          */
>         public void update(Graphics g) {
>     	paint(g);
>         }

>         /**
>          * Run the sorting algorithm. This method is
>          * called by class Thread once the sorting algorithm
>          * is started.
>          * @see java.lang.Thread#run
>          * @see SortItem#mouseUp
>          */
>         public void run() {
>     	try {
>     	    if (algorithm == null) {
>     		algorithm = (SortAlgorithm)Class.forName(algName).newInstance();
>     		algorithm.setParent(this);
>     	    }
>     	    algorithm.init();
>     	    algorithm.sort(arr);
>     	} catch(Exception e) {
>     	}
>         }

>         /**
>          * Stop the applet. Kill any sorting algorithm that
>          * is still sorting.
>          */
>         public synchronized void stop() {
>     	if (kicker != null) {
>                 try {
>     		kicker.stop();
>                 } catch (IllegalThreadStateException e) {
>                     // ignore this exception
>                 }
>     	    kicker = null;
>     	}
>     	if (algorithm != null){
>                 try {
>     		algorithm.stop();
>                 } catch (IllegalThreadStateException e) {
>                     // ignore this exception
>                 }
>     	}
>         }

>         /**
>          * For a Thread to actually do the sorting. This routine makes
>          * sure we do not simultaneously start several sorts if the user
>          * repeatedly clicks on the sort item.  It needs to be
>          * synchronoized with the stop() method because they both
>          * manipulate the common kicker variable.
>          */
>         private synchronized void startSort() {
>     	if (kicker == null || !kicker.isAlive()) {
>     	    scramble();
>     	    repaint();
>     	    kicker = new Thread(this);
>     	    kicker.start();
>     	}
>         }

>         /**
>          * The user clicked in the applet. Start the clock!
>          */
>         class MyAdapter extends MouseAdapter {
>             public void mouseClicked(MouseEvent evt) {
>     	    startSort();
>             }
>         }
>     }

Y aquí tienes los tres applets de ordenación trabajando bajo el JDK 1.1:

Método Burbuja | Método Burbuja Bidireccional | Ordenación Rápida

Para más detalles sobre éstos y otros cambios en el AWT puedes ver la sección Cambios en el GUI: El AWT crece.

Ozito