Java non sembra essere il confronto Doubles destra
Domanda
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.
Soluzione
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.
Altri suggerimenti
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)