可比Java

我有一个家庭作业，有点麻烦。首先，任务是制作一个不同大小的条形图，然后通过单击按钮对其进行调整和排序。我在主类上实现了action listener，然后在第二个类上实现了comparable。调用可比较函数时出现问题。它说我的数组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

}

import java.util.*；
导入java.applet.applet；
导入java.awt.*；
导入java.awt.event.*；
导入javax.swing.*；
公共类TwoSorts扩展小程序实现ActionListener
{
专用最终int小程序_宽度=600；
专用最终int小程序_高度=600；
按钮排序；
标签分类\标签；
字符串pr_名称；
int[]随机=新int[20]；
int[]分拣机=新int[20]；
公共void init（）
{
排序=新按钮（“排序”）；
添加（排序）；
sort.addActionListener（this）；
sort_label=新标签（“橙色选择/黑色气泡”）；
添加（分拣标签）；
随机基因（随机）；
分拣机=随机；
挫折地面（颜色：白色）；
设置大小（小程序宽度、小程序高度）；
}  
私有void randomGen（int…random）{
对于（int i=0；i<20；i++）{
random[i]=（int）（20+（Math.random（）*300-20））；
}
}
公共空间涂料（图g）
{
对于（int i=0；i<20；i++）{
g、 setColor（Color.blue）；
g、 fillRect（（int）（10+（i*50）），300,50，（（random[i]））；
g、 设置颜色（颜色为黑色）；
g、 fillRect（（int）（10+（i*50）），300,25，（分类器[i]）；
}
g、 drawRect（20,30,130,50）；
排序设置位置（0220）；
分拣标签设置位置（0270）；
分类标签设置尺寸（400,30）；
}
集体行动扩展了两个类别{
已执行的公共无效操作（操作事件arg0）{
选择排序（随机）；
插入排序（排序）；
重新油漆；
公共静态无效选择排序（可比[]随机）{
int-min；
可比温度；
对于（int index=0；index0&&key.compareTo（分拣机[位置-1]）<0）{
分拣机[位置]=分拣机[位置-1]；
位置--；
}
分拣机[位置]=钥匙；
}
}
@凌驾
公共整数比较对象（对象o）{
//TODO自动生成的方法存根
返回0；
}
}
@凌驾
已执行的公共无效操作（操作事件e）{
//TODO自动生成的方法存根
}

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

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

如果有一个名为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);

List愚人主义者=create愚人主义者（）；
集合。排序（傻瓜）；

---

更好的是，您可以实现一个类型化的可比较接口（可能更容易混淆）

这样可以避免铸造：

Class Foo implements Comparable<Foo> {
    Integer fooIndex;

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

类Foo实现了可比较的{
整数指数；
比较（Foo其他Foo）{
返回此.fooIndex.compareTo（otherFoo.fooIndex）；
}
}

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

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

如果有一个名为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);

List愚人主义者=create愚人主义者（）；
集合。排序（傻瓜）；

---

更好的是，您可以实现一个类型化的可比较接口（可能更容易混淆）

这样可以避免铸造：

Class Foo implements Comparable<Foo> {
    Integer fooIndex;

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

类Foo实现了可比较的{
整数指数；
比较（Foo其他Foo）{
返回此.fooIndex.compareTo（otherFoo.fooIndex）；
}
}

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

例如，如果你有一个需要排序的矩形条形图，你可以创建一个包含矩形高度、宽度和位置的矩形类。现在，由于这是你创建的一个类，你需要实现compareTo函数来计算哪个矩形大于或小于另一个矩形

如果查看compareTo（）规范，您将看到：

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

因此，如果该对象小于传递给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();
    }
}

---

显然，我遗漏了很多，但这应该会让你找到正确的方向。好好玩玩，看看你能想出什么。快乐的编码！

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

所以