Implementieren "tolerant" `equals` &` hashCode` für eine Klasse mit Gleitkommamitgliedern

Question

Ich habe eine Klasse mit einem float Feld. Zum Beispiel:

public class MultipleFields { 
    final int count; 
    final float floatValue; 

    public MultipleFields(int count, float floatValue) { 
    this.count = count; 
    this.floatValue = floatValue; 
    } 

} 

Ich muss in der Lage sein, Instanzen nach Wert zu vergleichen. Nun, wie kann ich equals & hashCode richtig implementieren?

Die übliche Art zu implementieren equals und hashCode ist nur alle Felder zu berücksichtigen. Z.B. Eclipse wird die folgende equals erzeugen:

public boolean equals(Object obj) { 
    // irrelevant type checks removed 
    .... 
    MultipleFields other = (MultipleFields) obj; 
    if (count != other.count) 
     return false; 
    if (Float.floatToIntBits(floatValue) != Float.floatToIntBits(other.floatValue)) 
     return false; 
    return true; 
    } 

(und eine ähnliche hashCode, daß im wesentlichen berechnet count* 31 + Float.floatToIntBits(floatValue)).

Das Problem dabei ist, dass meine FP-Werte Rundungsfehler unterliegen (sie können von Benutzereingaben, von einem DB, etc. stammen). Also brauche ich einen "toleranten" Vergleich. Die gemeinsame Lösung besteht darin, einen Epsilon-Wert zu vergleichen (siehe z.B. Comparing IEEE floats and doubles for equality). Allerdings bin ich nicht ganz sicher, wie ich equals mit dieser Methode implementieren kann, und immer noch eine hashCode, die mit equals konsistent ist.

Meine Idee ist es, die Anzahl der signifikanten Stellen für den Vergleich, dann immer rund auf diese Anzahl von Ziffern in beide equals und hashCode zu definieren:

long comparisonFloatValue = Math.round(floatValue* (Math.pow(10, RELEVANT_DIGITS))); 

Dann, wenn ich alle Verwendungen von floatValue mit comparisonFloatValue in equals ersetzen und sollte ich einen "toleranten" Vergleich bekommen, der mit hashCode übereinstimmt.

• Funktioniert das?
• Sehen Sie irgendwelche Probleme mit diesem Ansatz?
• Gibt es einen besseren Weg, dies zu tun? Es scheint ziemlich kompliziert.

Answer 1

Das große Problem dabei ist, dass zwei Float-Werte noch sehr nahe beieinander sein könnten, aber vergleichen noch ungleich. Im Grunde teilen Sie den Bereich der Gleitkommawerte in Buckets - und zwei Werte könnten sehr nahe beieinander liegen, ohne sich im selben Bucket zu befinden. Stellen Sie sich vor, Sie verwenden zwei signifikante Ziffern, indem Sie trunkation anwenden, um beispielsweise den Bucket zu erhalten ... dann wären 11.999999 und 12.000001 ungleich, aber 12.000001 und 12.9999999 wären gleich, obwohl sie viel weiter voneinander entfernt sind.

Wenn Sie nicht Bucket-Werte wie folgt verwenden, können Sie Equals aufgrund von Transitivität nicht entsprechend implementieren: x und y können eng beieinander liegen, y und z können eng beieinander liegen, aber das ist nicht möglich bedeuten, dass x und z nahe beieinander liegen.