BigDecimal equals

Es gäbe hier keinen Unterschied, aber es lassen sich leicht Beispiele finden, wo es einen Unterschied macht. Das Problem ist normalerweise nicht die einzelne Berechnungen, sondern das Aufschaukeln wenn man mehrere Berechnungen hintereinander ausführt.

Wieso muss immer so komisch formatiert werden? @ Thread Irgendwas

Man muss hier unterscheiden, Zwischenrechnung, Endrechnung, genauigkeit-erhöhende/-verringernde Rechnung, Datentyp. Von mir aus kannst du auch ankommen mit IEEE.

Edit: Sry, verlustbehaftet und so, dem genauem Vokabular will ich mich hier nicht bedienen.

*** Edit ***

Mach das doch so:

 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pkg27inhalteladen;

import java.util.Random;

/**
 * @author CB
 */
public class MyDouble /* extends java.lang.Double */ {
    
    private final Double d;
    
    public MyDouble(Double d) {
        if (d == null) {
            throw new IllegalArgumentException();
        }
        this.d = d;
    }
    
    @Override
    public int hashCode() {
        return d.hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final MyDouble other = (MyDouble) obj;
        return this.d == other.d || (this.d != null && (this.d.equals(other.d)
                || Math.abs(this.d - other.d) < 0.0000000001));
    }
    // toString here ...
    public static void main(String[] args) {
        Random r = new Random();
        MyDouble[] mda = new MyDouble[1000];
        while (true) {
            for (int i = 0; i < mda.length; i++) {
                mda** = new MyDouble(r.nextDouble());
            }
            for (int i = 0; i < mda.length - 1; i++) {
                for (int j = i + 1; j < mda.length; j++) {
                    if (mda**.equals(mda[j])) {
                        System.out.println("i = " + i);
                        System.out.println("j = " + j);
                        System.out.println("mda**.d = " + mda**.d);
                        System.out.println("mda[j].d = " + mda[j].d);
                        return;
                    }
                }
            }
        }
    }
}```

(blöde Werbung von Netbeans ignorieren)

Double ist leider final ... d wäre eigentlich "von außen" nicht zu sehen ...

Was garantiert mir das?, "ungefähr" dass die ersten 10 Nachkommastellen gleich sind.

Was passiert da eigentlich?, n doubles werden generiert, dann wird geschaut, ob es ein x und ein y gibt, s. d. x!=y und x==y.

Wäre das einfacher möglich?, jaein.

Ist eine Klammer überflüssig?, ja.