Java 双类型比较器

我编写了以下代码：

public class NewClass2 implements Comparator<Point>
{
    public int compare(Point p1, Point p2)
    {
        return (int)(p1.getY() - p2.getY());
    }
}

公共类NewClass2实现了Comparator
{
公共整数比较（点p1，点p2）
{
返回（int）（p1.getY（）-p2.getY（））；
}
}

如果我假设有两个双数，

3.2-3.1

，那么差应该是

0.1

。但是，当我将数字转换为int时，差异最终为

0

，这是不正确的

因此，我需要

compare（）

返回一个double，而不是int。问题是，我的

getX

字段是一个double。如何解决此问题？

该方法应返回一个

int

。它是一个数字，可以是：

• 如果第一个值小于第二个值，则小于零
• 如果两个值相等，则等于零
• 如果第一个值大于第二个值，则大于零

您不需要返回一个

double

。必须返回

int

以实现

比较器

接口。您只需根据我上面概述的规则返回正确的

int

您不能简单地从int进行强制转换，正如您所说，差0.1将导致0。您可以简单地执行以下操作：

public int compare(Point p1, Point p2)
{
    double delta= p1.getY() - p2.getY();
    if(delta > 0) return 1;
    if(delta < 0) return -1;
    return 0;
}

公共整数比较（点p1，点p2） { 双增量=p1.getY（）-p2.getY（）； 如果（增量>0），则返回1； if（delta<0）返回-1； 返回0； } 但是，由于比较浮点值总是很麻烦，您应该在一定范围内进行比较（请参阅），如下所示：

public int compare(Point p1, Point p2)
{
    double delta = p1.getY() - p2.getY();
    if(delta > 0.00001) return 1;
    if(delta < -0.00001) return -1;
    return 0;
}

public class NewClass2 implements Comparator<Point> {
    public int compare(Point p1, Point p2) {
        return Double.compare(p1.getY(), p2.gety());
    }    
}

Double::compare

公共整数比较（点p1，点p2） { 双增量=p1.getY（）-p2.getY（）； 如果（delta>0.00001）返回1； 如果（增量<-0.00001）返回-1； 返回0； } 该方法应返回一个

int

。它是一个数字，可以是：

• 如果第一个值小于第二个值，则小于零
• 如果两个值相等，则等于零
• 如果第一个值大于第二个值，则大于零

您不需要返回一个

double

。必须返回

int

以实现

比较器

接口。您只需根据我上面概述的规则返回正确的

int

您不能简单地从int进行强制转换，正如您所说，差0.1将导致0。您可以简单地执行以下操作：

public int compare(Point p1, Point p2)
{
    double delta= p1.getY() - p2.getY();
    if(delta > 0) return 1;
    if(delta < 0) return -1;
    return 0;
}

公共整数比较（点p1，点p2） { 双增量=p1.getY（）-p2.getY（）； 如果（增量>0），则返回1； if（delta<0）返回-1； 返回0； } 但是，由于比较浮点值总是很麻烦，您应该在一定范围内进行比较（请参阅），如下所示：

public int compare(Point p1, Point p2)
{
    double delta = p1.getY() - p2.getY();
    if(delta > 0.00001) return 1;
    if(delta < -0.00001) return -1;
    return 0;
}

public class NewClass2 implements Comparator<Point> {
    public int compare(Point p1, Point p2) {
        return Double.compare(p1.getY(), p2.gety());
    }    
}

Double::compare

公共整数比较（点p1，点p2） { 双增量=p1.getY（）-p2.getY（）； 如果（delta>0.00001）返回1； 如果（增量<-0.00001）返回-1； 返回0； }

---

您不需要返回

double

比较器

接口用于为被比较的元素建立顺序。使用

double

的字段与此排序无关

你的代码很好

对不起，我错了，再次阅读问题，这是您需要的：

public class NewClass2 implements Comparator<Point> {
    public int compare(Point p1, Point p2) {
        if (p1.getY() < p2.getY()) return -1;
        if (p1.getY() > p2.getY()) return 1;
        return 0;
    }    
}

公共类NewClass2实现了Comparator{
公共整数比较（点p1，点p2）{
if（p1.getY（）p2.getY（））返回1；
返回0；
}    
}

您不需要返回

double

比较器

接口用于为被比较的元素建立顺序。使用

double

的字段与此排序无关

你的代码很好

对不起，我错了，再次阅读问题，这是您需要的：

public class NewClass2 implements Comparator<Point> {
    public int compare(Point p1, Point p2) {
        if (p1.getY() < p2.getY()) return -1;
        if (p1.getY() > p2.getY()) return 1;
        return 0;
    }    
}

公共类NewClass2实现了Comparator{
公共整数比较（点p1，点p2）{
if（p1.getY（）p2.getY（））返回1；
返回0；
}    
}

我建议您使用内置方法Double.compare（）。如果需要双值相等的范围，可以首先使用chcek

return Double.compare(p1.getY(), p2.gety());

或

if（Math.abs（p1.getY（）-p2.getY（））

---

使用<和>的问题是，在这两种情况下，NaN都将返回false，这可能导致处理不一致。e、 g.NaN被定义为不等于任何东西，即使是它本身，但是在@suihock和@Martinho的解决方案中，如果其中一个值为NaN，则该方法每次都将返回0，这意味着NaN等于所有东西。

我建议您使用内置方法Double.compare（）。如果需要双值相等的范围，可以首先使用chcek

return Double.compare(p1.getY(), p2.gety());

或

if（Math.abs（p1.getY（）-p2.getY（））

---

使用<和>的问题是，在这两种情况下，NaN都将返回false，这可能导致处理不一致。e、 g.NaN被定义为不等于任何东西，即使它本身也不等于任何东西，但是在@suihock和@Martinho的解中，如果其中一个值为NaN，则该方法每次都将返回0，这意味着NaN等于所有东西。

好吧，在转换为整数之前，可以将这些双数值乘以适当的因子，例如，在你的情况下，因为它只有一个小数位，所以10是一个很好的因数

return (int)(p1.getY()*10 - p2.getY()*10);

---

好的，在转换成整数之前，你可以用一个适当的因子乘以那些双精度值，例如，在你的例子中，因为它只有一个小数位，所以10是一个好因子

return (int)(p1.getY()*10 - p2.getY()*10);

---

我只想进一步介绍Peter Lawrey对JDK 8的回答，如果您这样做：

public int compare(Point p1, Point p2)
{
    double delta = p1.getY() - p2.getY();
    if(delta > 0.00001) return 1;
    if(delta < -0.00001) return -1;
    return 0;
}

public class NewClass2 implements Comparator<Point> {
    public int compare(Point p1, Point p2) {
        return Double.compare(p1.getY(), p2.gety());
    }    
}

Double::compare

更好的是，您可以使用如下成员引用：

public int compare(Point p1, Point p2)
{
    double delta = p1.getY() - p2.getY();
    if(delta > 0.00001) return 1;
    if(delta < -0.00001) return -1;
    return 0;
}

public class NewClass2 implements Comparator<Point> {
    public int compare(Point p1, Point p2) {
        return Double.compare(p1.getY(), p2.gety());
    }    
}

Double::compare

---

我只想进一步介绍Peter Lawrey对JDK 8的回答，如果您这样做：

public int compare(Point p1, Point p2)
{
    double delta = p1.getY() - p2.getY();
    if(delta > 0.00001) return 1;
    if(delta < -0.00001) return -1;
    return 0;
}

public class NewClass2 implements Comparator<Point> {
    public int compare(Point p1, Point p2) {
        return Double.compare(p1.getY(), p2.gety());
    }    
}

Double::compare

更好的是，您可以使用如下成员引用：

public int compare(Point p1, Point p2)
{
    double delta = p1.getY() - p2.getY();
    if(delta > 0.00001) return 1;
    if(delta < -0.00001) return -1;
    return 0;
}

public class NewClass2 implements Comparator<Point> {
    public int compare(Point p1, Point p2) {
        return Double.compare(p1.getY(), p2.gety());
    }    
}

Double::compare

---

由于Java1.8，您还可以使用

Comparator.comparingDouble(p -> p.getY())