Question

我正在尝试在查询结果中使用min distance, min speed and max speed获取记录。目前我的距离最短，但我遇到了获得最小和最大速度的问题，我问自己是否可以在public int compareTo(BehaviourItem otherItem)课程中添加另一个BehaviourItem方法来达到此目的但我我收到错误Duplicate method compareTo(BehaviourItem) in type BehaviourItem。

如何从BehaviourItem班级获得最低和最高速度？

代码：

         PreparedStatement prepared = con
                 .prepareStatement("SELECT speed, stop_distance from behaviour where mac = ? and stop_name = ?");
                 prepared.setString(1, macD);
                 prepared.setString(1, sto_nam);
                 ResultSet rsBehav = prepared.executeQuery();
                 List<BehaviourItem> behavList = new ArrayList<BehaviourItem>();
                 while (rsBehav.next()) {
                     int distance = rsBehav.getInt("stop_distance");
                     int speed = rsBehav.getInt("speed");
                     BehaviourItem behItem = new BehaviourItem(distance, speed);
                     behavList.add(behItem);

                 }
                 Collections.sort(behavList);
                 int minDistance =  behavList.get(0).getDistance();

BehaviourItem类：

public class BehaviourItem implements Comparable<BehaviourItem>{
    int speed;
    int distance;

    public BehaviourItem(int speed, int distance) {
        super();
        this.speed = speed;
        this.distance = distance;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public int getDistance() {
        return distance;
    }

    public void setDistance(int distance) {
        this.distance = distance;
    }

    @Override
    public int compareTo(BehaviourItem otherItem) {
        // TODO Auto-generated method stub
        return Integer.compare(this.distance, otherItem.distance);
    }

}

Answer 1

您不应让BehaviourItem实施Comparable，因为它没有自然顺序。相反，为不同的属性实现不同的Comparators。

请注意，在Java 8中，您可以将<{1}}简单地实现为

Comparator

相当于

Comparator<BehaviourItem> orderBySpeed=Comparator.comparingInt(BehaviourItem::getSpeed);

或

Comparator<BehaviourItem> orderBySpeed=new Comparator<BehaviourItem>() {
    public int compare(BehaviourItem a, BehaviourItem b) {
        return Integer.compare(a.getSpeed(), b.getSpeed());
    }
};

为其他财产。

几乎每个使用订单的收集方法都有一个重载支持传递Comparator<BehaviourItem> orderByDistance =Comparator.comparingInt(BehaviourItem::getDistance);来定义订单而不是使用自然顺序：

Comparator

RESP。

Collections.sort(behavList, orderBySpeed);

您甚至可以创建比较器ad-hoc：

Collections.sort(behavList, orderByDistance);

和

Collections.sort(behavList, Comparator.comparingInt(BehaviourItem::getDistance));

但是流API允许您在不进行排序的情况下查找最小值或最大值：

Collections.sort(behavList, Comparator.comparingInt(BehaviourItem::getSpeed));

Answer 2

Comparable基本上定义了一个具有自然顺序的对象（例如数字），因此只能有一个compareTo()方法。

要获得一个值的最小值/最大值，您可以使用已排序的集合，例如列表，并访问第一个和最后一个元素。

但是，由于您的BehaviourItem没有自然顺序（是根据速度还是距离？），您必须根据情况定义顺序。这就是Comparator发挥作用的地方：当你想要按速度排序时，你可以使用比较速度的比较器，如果你想按距离排序，你可以使用比较器来测量距离等。

当然，如果速度和距离变化很大，你总是需要获得最小/最大值，你也可以迭代所有项目并选择最小/最大经典方式。

另一个选项，因为你正在使用查询，可能是直接添加min(speed), max(speed)等。这可能需要单独的查询或添加到每个结果行，这反过来可能会降低查询速度，但如果你只得到几行它可能还是值得的。

Answer 3

您无法在compareTo()类中定义另一个BehaviourItem函数，但您可以创建自定义比较器并使用它来对列表进行排序。

自定义比较器的一个示例 -

public class BehaviourItem implements Comparable<BehaviourItem>{
    .
    .
    .

    @Override
    public int compareTo(BehaviourItem otherItem) {
        // TODO Auto-generated method stub
        return Integer.compare(this.distance, otherItem.distance);
    }

    static class BehaviourItemComparator implements Comparator<BehaviourItem>
    {            
         public int compare(BehaviourItem b1, BehaviourItem b2)
         {
             return Integer.compare(b1.getSpeed(), b2.getSpeed());
         }
     }

}

然后你可以用它作为 -

Collections.sort(behavList, BehaviourItem.BehaviourItemComparator)

Answer 4

使用Comparator代替Comparable。

您可以根据需要定义任意数量的排序行为。

使用可比较

4 个答案: