正确执行equals（） - 分数的方法

Question

我希望printn方法给我“Asterix”和“Oberlix”，因为3/4与6/8相同。

HashMap hm = new HashMap(); 
hm.put(new Fraction(3, 4), "Asterix"); 
hm.put(new Fraction(19, 12), "Oberlix"); 
System.out.println(hm.get(new Fraction(6, 8))); 
System.out.println(hm.get(new Fraction(38, 24))); 

所以这是我是如何实现的等号方法：

public boolean equals(Object obj) { 
    boolean isEqual = false; 

    if(obj instanceof Fraction) { 
     Fraction frac = (Fraction) obj; 

     if(((double) this.numerator/(double) this.denumerator) == ((double) frac.numerator/(double) frac.denumerator)) { 
      isEqual = true; 
     } 
    } 
    return isEqual; 
} 

很显然，我做错了什么事，因为这不工作，我的打印方法返回“空”。我的想法是，如果我将这两个分数的分子和分母分开，结果必须相等，如果分数相等（3/4与6/8相同）。

对不起，我猜这个错误肯定是显而易见的，但我找不到它。

Answer 1

你不应该把==加倍，因为System.out.println(0.1+0.1+0.1)并不总是0.3（对我来说，它输出0.30000000000000004）。从Double使用equals或compare方法。

因为你是存储在您的Fraction类分子和denumenator，你应该在你的equals方法使用足够接近条件使用自定义小量：

public boolean equals(Object obj) { 
    boolean isEqual = false; 

    if(obj instanceof Fraction) { 
     Fraction frac = (Fraction) obj; 

     if(Math.abs(((double)this.numerator)/this.denumerator) - ((double)frac.numerator)/frac.denumerator) < .00000001/*epsilon*/) { 
      isEqual = true; 
     } 
    } 
    return isEqual; 
} 

此外，您将需要重写hashCode类别中的方法Fraction以便使用HashMap。由于这equals实现只依赖于一个值（分数的结果），你可以使用以下内容：

public int hashCode() 
{ 

    return 0;//all Fraction return the same hashCode, which make HashMap call equals each time 

    //EDIT: the following is WRONG: assuming eps = 0.1, 299/100 is equals to 300/100 but hashCode will be different (2 and 3). 

    //return this.numerator/this.denumerator ;//since those are int (I guess), 
    //it will truncate the floating part. So you will just check for the integer part. 


} 

Answer 2

对于HashMap工作，你必须实现equals和hashCode。我只提供部分答案，因为我没有太多时间，所以只有equals。

要比较两个分数而不求助于double s，只需做一些简单的算术。你有两个分数，a/b和c/d。假设分母为零：

a/b == c/d 
    (multiply left and right by b) 
a == c/d*b 
    (multiply left and right by d) 
a*d == c*b 

所以：

public boolean equals(Object obj) { 
    if (!(obj instanceof Fraction)) { 
    return false; 
    } 
    Fraction other = (Fraction) obj; 
    return this.numerator * other.denominator == other.numerator * this.denominator; 
} 

请注意，这不会对非常大的部分工作;他们会溢出。如果你想正确处理这些问题，可以投入很长时间。

---

为了实现hashCode，你可以用欧几里德算法简化分数，然后异或分子和分母的哈希码。

Answer 3

作为上面的帖子，解决方法是使用“hasCode（）”而不是equals（）。
这里是你如何能得到适当的hashCode一个选项：

@Override 
    public int hashCode() { 
     // Calculating with double is troublesome sometimes, so i use BigDecimal here 
     BigDecimal value = BigDecimal.valueOf(this.numerator).divide(BigDecimal.valueOf(this.denumerator), RoundingMode.HALF_UP); 
     // after this, i just return the hashCode i would get, if if my parameter was a simple Double Value: 
     return Double.valueOf(value.doubleValue()).hashCode(); 
    } 

希望这有助于！

Answer 4

你可以为做等于

return denominator * other.numerator == numerator * other.denominator; 

但更好的是要规范的分数。 在等于或在构造函数中标准化分数：6/8变为3/4。

public class Fraction implements Number { 
    private final int numerator; 
    private final int denominator; 

    public Fraction(int numerator, int denominator) { 
     if (denominator < 0) { 
      denominator = -denominator; 
      numberator = -numerator; 
     } 
     int commonFactor = gcd(numerator, denominator); 
     this.numerator = numerator/commonFactor; 
     this.denominator = denominator/commonFactor; 
    } 

    @Override 
    public boolean equals(Object other) { 
     ... 
     Fraction otherFraction = ... 
     return denominator == otherFraction.denominator 
      && numerator == otherFraction.numerator; 
    } 

    private static int gcd(int x, int y) { 
     x = Math.abs(x); 
     y = Math.abs(y); 
     ... 
     while (x != y) { 
      if (x > y) { 
       x -= y; 
      } else { 
       y -= x; 
      } 
     } 
     return x; 
    } 

什么是更好的？现在你可以让一个hashCode：

@Override 
int hashCode() { 
    return denominator * 31 + numerator; 
} 

浮点是2