1

我有一个家庭作业，并且遇到了一些麻烦。首先，任务是制作一个不同大小的条形图，然后通过每次单击按钮对其进行调整和排序。我在主类上实现了动作监听器，然后制作了一个辅助类来实现可比性。我在调用可比较函数时遇到问题。它说我的数组 int[] 无法以寻找可比较 [] 的可比较方法解决，任何帮助或提示将不胜感激。这是我的代码：

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

}
4

3 回答 3

4

Comparable 应该由您可能有理由与相同类型的其他对象进行比较的类实现。

例如，如果您有一个需要排序的矩形条形图，您可能会创建一类矩形，其中包含矩形的高度、宽度和位置。现在，由于这是您编写的一个类，您将需要实现 compareTo 函数来评估哪个 Rectangle 大于或小于另一个矩形。

如果您查看 compareTo() 规范http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Comparable.html，您将看到：

返回： 负整数、零或正整数，因为此对象小于、等于或大于指定对象。

因此，如果此对象小于传递给 compareTo() 的对象，则返回 - ，如果等于 0，则 + 如果更大。

考虑到这一点，您最终可能会得到一个看起来像这样的类

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

显然，我遗漏了很多内容，但这应该会让您指出正确的方向。玩它，看看你想出了什么。快乐编码！

于 2012-11-06T03:09:57.420 回答
1

Comparable是一个接口，应该由一个可以排序的类来实现。

要实现Comparable，您只需实现一个方法compareTo，它将给定对象与另一个对象进行比较。

如果你有一个可以排序的名为Foo的对象，Foo 应该实现 Comparable。

这允许您对 Foo 对象的集合进行排序。

class Foo implements Comparable {
    Integer fooIndex;

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

上面是一个简单的compareTo方法的例子。

请注意，它不检查 null，也不检查是否可以强制转换为 Foo。

上面的实现允许你这样做：

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

更好的是，您可以实现一个类型化的Comparable 接口（可能更令人困惑）。

这使您可以避免强制转换：

Class Foo implements Comparable<Foo> {
    Integer fooIndex;

    compareTo(Foo otherFoo) {
        return this.fooIndex.compareTo(otherFoo.fooIndex);
    }
}
于 2012-11-06T03:05:42.320 回答
0

实现Comparable<T>接口取决于要排序的类的对象。可以将实现的compareTo(T)方法委托给此类的实例字段以确定对象的顺序。

最初，类 T 的对象保存在一个集合中List<T> list。使用 Comparable 界面，您可以通过两种方式对集合进行排序： Collections.sort(list);或Set set = new TreeSet(list);. Collections 类对原始列表进行排序，而 TreeSet(list) 创建一个新的排序集合。对于这两种工作方式，列表中的对象必须实现 Comparable 接口。

使用的排序算法是 Collections 类的合并排序，它不能更改。Collections.sort() 方法将元素排序任务委托给Arrays.sort(list.toArray()). 在内部，Arrays 类将对象转换为 Comparable 并调用 compareTo() 方法来执行元素的比较。

因此，如果您对执行选择排序或插入排序感兴趣，那么您可以遵循 JDK 策略。可以实现实现各种排序算法的类，该类将采用实现 Comparable 接口的对象数组。

于 2012-11-06T04:29:24.040 回答