Come test per vedere se un doppio è uguale a NaN?


Risposte:


476

Utilizzare la statica Double.isNaN(double)metodo, o il vostro Double's .isNaN()metodo.

// 1. static method
if (Double.isNaN(doubleValue)) {
    ...
}
// 2. object's method
if (doubleObject.isNaN()) {
    ...
}

Semplicemente facendo:

if (var == Double.NaN) {
    ...
}

non è sufficiente a causa della definizione dello standard IEEE per i numeri NaN e in virgola mobile .


51
Un altro modo per farlo sarebbe v! = V. Solo NaN confronta falso con se stesso. Non farlo però, isNaN è un milione di volte migliore. :)
Joren,

5
@Joren, meglio tardi che mai: 'isNaN' è davvero meglio usare di v! = V per leggibilità. Ma il codice sorgente del metodo isNaN è esattamente lo stesso che dice v! = V. Fonte: isNaN pubblico booleano statico (doppia v) {return (v! = V); }
Rolf ツ

1
Double.isNaN should be (true) bella risposta
Oliver Shaw,

@Joren isNaN basta controllare v! = V;) ma sembra migliore
Mr Jedi

Utilizzo di Java 5: value == Double.NaNnon funziona, ma Double.isNaN(value)funziona perfettamente.
zero01alpha,

45

Prova Double.isNaN():

Restituisce vero se questo doppio valore è un non-un-numero (NaN), falso altrimenti.

Si noti che [ double.isNaN()] non funzionerà, poiché i doppi non boxati non hanno metodi associati.


Pensavo non potessi chiamare metodi su tipi primitivi in ​​Java. Ha davvero bisogno di essere Double.isNan()e non double.IsNan(), giusto?
Joren,

Joren, si affida all'autoboxing (double viene convertito in Double dal compilatore / runtime); nuova funzione da 1.5 in poi. Poco rischio andando in questa direzione; passare dal doppio al doppio crea il rischio di NullPointerExceptions.
M1EK,

Pensavo che l'autoboxing funzionasse solo usando il doppio come argomento, aggiungendolo a una raccolta e simili. Prova a dichiarare double x e poi chiedere x a isNaN () - mi dà un errore del compilatore.
Carl,

Davvero, sospetto che Andrew abbia perso il tasto Maiusc digitando il primo "doppio".
Carl,

14

Si consiglia di verificare anche se un valore è finito tramite Double.isFinite(value). Da Java 8 esiste un nuovo metodo in Doubleclasse in cui è possibile verificare immediatamente se un valore non è NaN e infinito.

/**
 * Returns {@code true} if the argument is a finite floating-point
 * value; returns {@code false} otherwise (for NaN and infinity
 * arguments).
 *
 * @param d the {@code double} value to be tested
 * @return {@code true} if the argument is a finite
 * floating-point value, {@code false} otherwise.
 * @since 1.8
 */
public static boolean isFinite(double d)

10

È possibile verificare la presenza di NaN utilizzando var != var. NaNnon è uguale NaN.

EDIT : questo è probabilmente il metodo peggiore di gran lunga. È confuso, terribile per la leggibilità e cattiva pratica generale.


3
Qualcuno può spiegare il downvote? Lo so, in questo modo è molto male, ed isNanè meglio per la leggibilità, ma funziona, giusto? E il isNanmetodo usa questo per verificare NaN.
HyperNeutrino,

1
Immagino che il downvote sia dovuto al fatto che in questo modo è molto male e isNaN è migliore per la leggibilità.
Edward Falk,

1
Non ti ho sottovalutato, ma penso che qui sarebbe utile un commento aggiuntivo: se si confrontano wrapper come Float o Double, si finisce per confrontare i riferimenti in questo modo, non i loro valori, che sicuramente non è quello che si desidera.
Battle_Slug

3
@Battle_Slug Grazie per il commento. So che questa è una pessima idea, ma l'ho messa qui per completezza.
HyperNeutrino

isNaNfa questo sotto il cofano, ma come funziona? Come fa qualcosa a non eguagliarsi ??
Wilmol,

0

I principianti hanno bisogno di esempi pratici. quindi prova il seguente codice.

public class Not_a_Number {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    String message = "0.0/0.0 is NaN.\nsimilarly Math.sqrt(-1) is NaN.";        
    String dottedLine = "------------------------------------------------";     

    Double numerator = -2.0;
    Double denominator = -2.0;      
    while (denominator <= 1) {
        Double x = numerator/denominator;           
        Double y = new Double (x);
        boolean z = y.isNaN();
        System.out.println("y =  " + y);
        System.out.println("z =  " + z);
        if (z == true){
            System.out.println(message);                
        }
        else {
            System.out.println("Hi, everyone"); 
        }
        numerator = numerator + 1;
        denominator = denominator +1;
        System.out.println(dottedLine);         
    } // end of while

} // end of main

} // end of class

2
Questo esempio fa troppo, e non è chiaro cosa stavi cercando di mostrare. Questo è solo un mucchio di codice frammentato.
Jared Hooper,

3
Come OP, che era un principiante quando questa domanda fu fatta nel '09, posso assicurarti che la risposta accettata era molto più utile di questo esempio "pratico".
Eric Wilson,

Grazie @pggajendra babu per aver pubblicato questo codice di esempio.
dat

0

Lo snippet di codice seguente aiuterà a valutare il tipo primitivo tenendo NaN.

double dbl = Double.NaN; Double.valueOf(dbl).isNaN() ? true : false;

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.