Java non sembra essere il confronto Doubles destra

Question

Ho creato una lista collegata, con inserto, cercare e rimuovere funzioni. Ho anche creato un iteratore per esso. Ora, supponiamo che io faccio questo:

myList<Integer> test = new myList();
test.insert(30);
test.insert(20);
test.insert(10);
myList.iterator it = test.search(20);
if(it.hasNext())
    System.out.println(it.next());

E voilà, funziona (stampa il valore dell'elemento in corrispondenza del nodo, in questo caso 20). Ora, se faccio questo:

myList<Double> test = new myList();
test.insert(30.1);
test.insert(20.1);
test.insert(10.1);
myList.iterator it = test.search(20.1);
if(it.hasNext())
    System.out.println(it.next());

Non è così, perché l'iteratore punta a null. Ecco l'implementazione della funzione di ricerca:

public iterator search(T data)
{
    no<T> temp = first;
    while( (temp != null) && (temp.data != data) )
        temp = temp.next;
    return (new iterator(temp));
}

Ecco come so che c'è qualcosa di strano con i paragoni: Se cambio una parte del codice di cui sopra in questo modo:

while( (temp != null) && (temp.data != data) )
     System.out.println(temp.data + " " + data);
     temp = temp.next;

Lo vedo stampa i numeri nella lista. Esso stampa, a un certo punto, "20.1 20.1" (per esempio). Così come posso risolvere questo problema? La funzione sembra essere giusto, ma sembra proprio come se Java non è confrontare correttamente i numeri.

EDIT: wth, BigDecimal mi ha dato lo stesso tipo di problema troppo

.

EDIT 2: equals () ha lavorato, non si rese conto qualcos'altro non andava. Siamo spiacenti.

Answer 1

Se non si desidera l'Operatore! = Per questo. Si comapres riferimenti. Si desidera che il metodo di .equals():

public iterator search(T data)
{
    no<T> temp = first;
    while (!data.equals(temp.data)) {
        temp = temp.next;
    }
    return (new iterator(temp));
}

Inoltre, guardare fuori per auto-boxing . Potreste scoprire che le scatole test.search(20.1) 20.1 ad un non Float un Double, che probabilmente rompere il vostro confronto. Confrontare i risultati con test.search(20.1d). Se non ricordo male, l'espressione:

new Float(20.1).equals(new Double(20.1))

è falso.

Answer 2

Si noti che usando .equals() per confrontare raddoppia può portare ad errori. Double.equals() usa questo come il suo test di uguaglianza:

 d1.doubleValue() == d2.doubleValue()

Doppio e galleggia sono approssimazioni di numeri memorizzati in uno spazio fisso in memoria.

Al fine di confrontare correttamente numeri in virgola mobile , è necessario essere consapevoli del fatto che a causa della natura dei carri allegorici, ci sarà qualche errore.

vedi: http://www.google.com/search?q = floating point + + parità

Un modo rapido e semplice per confrontare doppie è quello di utilizzare Math.abs(a-b)<ACCEPTABLE_ERROR dove ACCEPTABLE_ERROR potrebbe essere .000000000001 a seconda di cosa esattamente il vostro fare. (Nota questo non gestisce i casi limite, come Nan e INFINITY)