Comment testez-vous pour voir si un double est égal à NaN?


284

J'ai un double en Java et je veux vérifier si c'est le cas NaN. Quelle est la meilleure façon de procéder?

Réponses:


476

Utilisez la statique Double.isNaN(double)méthode ou votre Doublede » .isNaN()méthode.

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

Faire simplement:

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

n'est pas suffisant en raison de la définition de la norme IEEE pour le NaN et les nombres à virgule flottante .


51
Une autre façon de procéder serait v! = V. Seul NaN compare false avec lui-même. Ne faites pas cela cependant, isNaN est un million de fois meilleur. :)
Joren

5
@Joren, mieux vaut tard que jamais: «isNaN» est en effet préférable à utiliser que v! = V pour la lisibilité. Mais le code source de la méthode isNaN revient exactement à dire v! = V. Source: statique public booléen isNaN (double v) {return (v! = V); }
Rolf ツ

1
Double.isNaN should be (true) belle réponse
Oliver Shaw

@Joren isNaN suffit de vérifier v! = V;) mais ça a l'air mieux
M. Jedi

Utiliser Java 5: value == Double.NaNne fonctionne pas, mais Double.isNaN(value)fonctionne très bien.
zero01alpha

45

Essayez Double.isNaN():

Renvoie true si cette valeur Double est un Not-a-Number (NaN), false sinon.

Notez que [ double.isNaN()] ne fonctionnera pas, car les doubles sans boîte n'ont pas de méthodes associées.


Je pensais que vous ne pouviez pas appeler de méthodes sur des types primitifs en Java. Cela doit vraiment être Double.isNan()et non double.IsNan(), non?
Joren

Joren, il s'appuie sur l'autoboxing (le double est converti en Double par le compilateur / runtime); nouvelle fonctionnalité à partir de 1.5. Peu de risques dans cette direction; passer de Double à Double crée un risque de NullPointerExceptions.
M1EK

Je pensais que la boîte automatique fonctionnait uniquement en utilisant le double comme argument, en l'ajoutant à une collection, etc. Essayez de déclarer double x puis de demander x à isNaN () - me donne une erreur de compilation.
Carl

Vraiment, je soupçonne qu'Andrew vient de manquer la touche Maj en tapant le premier "double".
Carl

14

Vous pouvez également envisager de vérifier si une valeur est finie via Double.isFinite(value). Depuis Java 8, il y a une nouvelle méthode dans la Doubleclasse où vous pouvez vérifier immédiatement si une valeur n'est pas NaN et l'infini.

/**
 * 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

Vous pouvez vérifier NaN en utilisant var != var. NaNn'est pas égal NaN.

EDIT : C'est probablement de loin la pire méthode. C'est déroutant, terrible pour la lisibilité et mauvaise pratique globale.


3
Quelqu'un peut-il expliquer le downvote? Je sais, cette façon est très mauvaise, et isNanest meilleure pour la lisibilité, mais cela fonctionne, non? Et la isNanméthode utilise cela pour vérifier NaN.
HyperNeutrino du

1
Je suppose que le downvote était parce que cette façon est très mauvaise, et isNaN est meilleur pour la lisibilité.
Edward Falk

1
Je ne vous ai pas déçu, mais je pense qu'un commentaire supplémentaire serait utile ici: si vous comparez des wrappers comme Float ou Double, vous finissez par comparer des références de cette façon, pas leurs valeurs, ce qui n'est certainement pas ce que vous voulez.
Battle_Slug

3
@Battle_Slug Merci pour le commentaire. Je sais que c'est une très mauvaise idée, mais je la mets ici pour être complet.
HyperNeutrino

isNaNfait cela sous le capot, mais comment ça marche? Comment quelque chose ne s'égale pas ??
wilmol

0

Les débutants ont besoin d'exemples pratiques. essayez donc le code suivant.

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
Cet exemple en fait trop, et ce que vous essayez de montrer n'est pas clair. Ce n'est qu'un tas de code fragmenté.
Jared Hooper

3
En tant que PO, qui était un débutant lorsque cette question a été posée en '09, je peux vous assurer que la réponse acceptée était bien plus utile que cet exemple "pratique" ne l'aurait été.
Eric Wilson

Merci @pggajendra babu d'avoir publié cet exemple de code.
datnt

0

L'extrait de code ci-dessous aidera à évaluer le type primitif contenant NaN.

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.