Java não parecem estar comparando Duplas direita

Question

Eu criei uma lista ligada, com a inserção, procurar e remover funções. Eu também criou um iterador para ele. Agora, suponha que eu faça o seguinte:

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 pronto, ele funciona (ele imprime o valor do elemento no nó, neste caso 20). Agora, se eu fizer isso:

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());

Ele não faz, porque o iterador está apontando para null. Aqui está a implementação da função de pesquisa:

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

Aqui está como eu sei que há algo duvidoso com as comparações: Se eu alterar parte do código acima assim:

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

Eu posso ver a impressão dos números na lista. Ela imprime, em um ponto, "20.1 20.1" (por exemplo). Então, como posso corrigir isso? A função parece estar certo, mas ele só parece como se o Java não é comparar os números corretamente.

EDIT:. Wth, BigDecimal me deu o mesmo tipo de problema também

EDIT 2: equals () trabalhou, não sabia que outra coisa estava errada. Desculpe.

Answer 1

Você não quer que o operador! = Para isso. Ele comapres referências. Você quer que o método .equals():

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

Além disso, atente para auto-boxing . Você pode achar que as caixas test.search(20.1) 20,1 a um Float não um Double, o que provavelmente vai quebrar a sua comparação. Comparar os resultados com test.search(20.1d). Se bem me lembro, a expressão:

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

é falsa.

Answer 2

Note que o uso de .equals() para comparar duplos pode levar a erros. Double.equals() usa isso como seu teste de igualdade:

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

Duplas e flutua aproximações de números armazenados em um espaço fixo na memória.

Para corretamente comparar números de ponto flutuante , você precisa estar ciente de que, devido à natureza de carros alegóricos, haverá algum erro.

ver: http://www.google.com/search?q = flutuante + ponto + igualdade

Uma maneira rápida e fácil comparar duplas é usar Math.abs(a-b)<ACCEPTABLE_ERROR onde ACCEPTABLE_ERROR poderia ser .000000000001 dependendo do que exatamente você está fazendo. (Note que este não lidar com casos extremos, como NaN e INFINITY)