可比的Java

Question

I have a homework assignment and am having a little bit of trouble. First the assignment is to make a bar graph of various sizes then adjust and sort them with each click of a button. I implemented action listener on the main class then made a secondary class to implement comparable. I have an issue calling the comparable function. It says my array int[] cant be resolved in a comparable method thats looking for comparable[] Any help or tips would be gratly appreciated. Here is my code:

import java.util.*;
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;

 import javax.swing.*;



 public class TwoSorts extends Applet implements ActionListener

 {
private final int APPLET_WIDTH = 600;
private final int APPLET_HEIGHT = 600;
Button sort;
Label sort_label;
String pr_name;
int[] random = new int[20];
int[] sorter = new int[20];


public void init()

{

    sort = new Button("Sort");
    add(sort);
    sort.addActionListener(this);
    sort_label = new Label("Orange Selection / Black Bubble");
    add(sort_label);
    randomGen(random);
    sorter = random; 
    setBackground (Color.white);
    setSize (APPLET_WIDTH, APPLET_HEIGHT); 
}  

private void randomGen (int...random) {


    for (int i = 0; i < 20; i++){
        random [i] = (int) (20 +(Math.random()*300-20));
        }
}

public void paint(Graphics g)
{
    for (int i = 0; i < 20; i++ ){


        g.setColor(Color.blue);
        g.fillRect((int) (10 + (i*50)), 300, 50, ((random[i])));
        g.setColor(Color.black);
        g.fillRect((int) (10 + (i*50)), 300, 25, (sorter[i]));
    }

    g.drawRect (20, 30, 130, 50);
  sort.setLocation(0,220);
  sort_label.setLocation(0,270);
  sort_label.setSize(400,30);
}


class action extends TwoSorts implements Comparable {


public void actionPerformed(ActionEvent arg0) {


    selectionSort(random);
    insertionSort (sort);
    repaint;

public static void selectionSort (Comparable[] random)  {

    int min;
    Comparable temp;

    for (int index = 0; index < random.length-1; index++)
    {
        min = index;
        for (int scan = index+1; scan < random.length; scan++)
            if (random[scan].compareTo(random[min]) < 0)
                min = scan;

        temp = random[min];
        random[min] = random[index];
        random[index] = temp;
    }

public static void insertionSort (Comparable[] sorter)  {

    for (int index = 1; index < sorter.length; index ++){
        Comparable key = sorter[index];
        int position = index;
        while (position > 0 && key.compareTo(sorter[position-1]) < 0){
            sorter [position] = sorter[position-1];
            position--;
        }

        sorter[position] = key;
    }
}

@Override
public int compareTo(Object o) {
    // TODO Auto-generated method stub
    return 0;
    }
}


@Override
public void actionPerformed(ActionEvent e) {
    // TODO Auto-generated method stub

}

Answer 1

Comparable should be implemented by classes with which you might have some reason to compare with other objects of the same type.

So for instance, If you have a bar graph of rectangles that need to be sorted you might make a class of rectangles which contains the height, width and position of the rectangle. now since this is a class you made up you will need to implement the compareTo function to evaluate which Rectangle is greater or less than another rectangle.

If you look at the compareTo() specification http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Comparable.html you will see:

Returns: a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

so if this object is less than the object passed to compareTo() return - , if equal 0, and + if greater.

Taking that into consideration you might end up with a class that looks something like this

public class MyRect implements Comparable {
    int width;      //width of the rectangle will probably not change
    int height;     //this might be the value you want to compare in compareTo() 
    point position;

    ...

    //getters and setters yada yada
    public int getHeight(){
        return this.height;
    }

    ...

    @Override
    public int compareTo(Object otherRect){

        // if this rectangle's height is greater than otherRect the difference should 
        // be positive, if equal 0, and if less than the difference will be negative
        // exactly as specification for compareTo() states.

        return this.height - (MyRect)otherRect.getHeight();
    }
}

Obviously I've left a lot out, but that should get you pointed in the right direction. Play around with it and see what you come up with. Happy coding!

Answer 2

Comparabl e is an interface that should be implemented by a class that can be sorted.

To implement Comparable you simply implement a method compareTo , which compares the given object to another object.

If you have an object named Foo that can be sorted, Foo should implement Comparable.

This allows you to sort a collection of Foo objects.

class Foo implements Comparable {
    Integer fooIndex;

    compareTo(Object otherObject) {
        Foo otherFoo = (Foo) otherObject;
        return this.fooIndex.compareTo(otherFoo.fooIndex);
    }
}

The above is a example of a simple compareTo method.

Note that it doesn't check for null, or check whether or not the cast to Foo is possible.

The above implementation allows you to do this:

List<Foo> fooList = createFooList();
Collections.sort(fooList);

---

Even better, you can implement a typed Comparable interface (possibly more confusing).

This allows you to avoid casting:

Class Foo implements Comparable<Foo> {
    Integer fooIndex;

    compareTo(Foo otherFoo) {
        return this.fooIndex.compareTo(otherFoo.fooIndex);
    }
}

Answer 3

Implementing Comparable<T> interface depends on the objects of the class you want to sort. The compareTo(T) method the implementation can be delegated to the instance fields of this class to determine the object ordering.

Initially the objects of the class T are held in a collection List<T> list . With the Comparable interface you can sort the collection in two ways: Collections.sort(list); or Set set = new TreeSet(list); . The Collections class sorts the original list and the The TreeSet(list) creates a new sorted collection.For both these ways to work the objects in the list have to implement the Comparable interface.

The sorting algorithm used is mergesort for the Collections class and it cannot be changed. The Collections.sort() method delegates the task of sorting the elements to Arrays.sort(list.toArray()) . Internally the Arrays class casts the object to a Comparable and calls the compareTo() method to perform the comparison of elements.

So if you're interested in performing selection sort or insertion sort then you can follow the JDK strategy. A class which implements the various sorting algorithms can be implemented which will take an array of objects that implement the Comparable interface.