I Java står "NaN" for "Not a Number". Det er ikke en type unntak, ganske overraskende er datatypen til NaN også et tall. Men ofte når nybegynnere programmerere får det utilsiktet, bruker de det videre i sine beregninger. Derfor kan inkompatible datatyper i Java når de brukes sammen forårsake en kastbar feil. Det er også ofte sett som
Ta for eksempel en titt på følgende utdrag.
java.lang.ArithmeticException: / by zero
regnes som det samme som NaN. Java behandler dem begge forskjellig. Forvirrende nok? For din omfattende forståelse vil vi dissekere hvordan disse er forskjellige fra hverandre. Mot slutten av denne artikkelen vil du lære om mulige operasjoner som ikke produserer et tall (nan), og noen enkle måter å håndtere det på.
Hva er NaN?
Så, hva er NaN? "NaN" som mange av dere har gjettet, brukes til å representere "Not a Number" i Java. Det er en spesiell flyttallsverdi for å betegne overløp og feil. Det genereres når et flyttall er delt på null eller hvis kvadratroten av et negativt tall beregnes.
public class NaN
{
public static void main(String[]args)
{
System.out.println(0.0 / 0.0); //zero divided by zero
System.out.println(Math.sqrt(-1)); //take sqrt of negative number
System.out.println(10.0 % 0); //taking mod by zero
}
}
Produksjon
NaN
NaN
NaN
I utdraget ovenfor kan du observere at NaN produseres som et resultat av 3 enkle operasjoner:
- Å dele en
float / double
null med null. - Ta under roten av et negativt tall (Math.sqrt(-x)). I matematikk resulterer det å ta kvadratroten av et negativt tall i et tenkt tall . Denne saken behandles ved å returnere NaN i Java.
- Å ta mod av et tall med null, vil returnere resten etter å ha delt en verdi med null. Derfor returneres NaN.
Hvordan er NaN forskjellig fra positiv og negativ uendelighet?
I henhold til IEEE 754-spesifikasjonen er det tre spesielle flyttall- og doble verdier for å håndtere grensetilfellene:- Positiv uendelighet
- Negativ uendelighet
- NaN
Hva er NaN()-metoden?
isNaN()
er en av de grunnleggende metodene i Java for å sjekke om det er en NaN-verdi eller ikke. Som vi diskuterte tre tilfeller ovenfor, er det på tide å teste hvordan isNaN()-metoden skiller mellom +infinity , -infinity og NaN-verdier.
public class isNaN
{ public static void main(String[]args)
{
Double posInfinity = +2.0 / 0.0;
Double negInfinity = -3.5 / 0.0;
Double nanVal = 50 % 0.0;
System.out.println ("+" + posInfinity + ".IsNaN() = " + posInfinity.isNaN());
System.out.println ( negInfinity + ".IsNaN() = " + negInfinity.isNaN());
System.out.println ( nanVal + ".IsNaN() = " + nanVal.isNaN());
}
}
Produksjon
+Infinity.IsNaN() = false
-Infinity.IsNaN() = false
NaN.IsNaN() = true
Hvordan sammenligne NaN-verdier?
Hver NaN-verdi regnes som distinkt. Dette betyr at ikke en eneste NaN er lik noen annen NaN. Etter dette prinsippet, hvis du sammenligner en verdi med en annen, er resultatet alltid negativt. Siden NaN er uordnet, så en numerisk sammenligning som involverer til og med en enkelt NaN returnerer falsk. Java gir Float.NaN og Double.NaN for konstante felt i begge klassene for å utføre sammenligninger. Vi kan skille disse i to separate scenarier:- Sant: Bare i tilfelle ulikhet (!=)
- False: For alle sammenligningsoperander (==, <=, >=, <, >)
public class ComparingNaN
{ public static void main(String[] args)
{
// Comparing NaN values for Float constants
System.out.println (Float.NaN != Float.NaN); // true
System.out.println (Float.NaN == Float.NaN); // false
System.out.println (Float.NaN < Float.NaN); // false
System.out.println (Float.NaN > Float.NaN); // false
System.out.println (Float.NaN <= Float.NaN); // false
System.out.println (Float.NaN >= Float.NaN); // false
// Comparing NaN values for Float constants
System.out.println (Double.NaN != Double.NaN); // true
System.out.println (Double.NaN == Double.NaN); // false
System.out.println (Double.NaN < Double.NaN); // false
System.out.println (Double.NaN > Double.NaN); // false
System.out.println (Double.NaN <= Double.NaN); // false
System.out.println (Double.NaN >= Double.NaN); // false
}
}
Hvordan generere NaN-verdier?
Før vi avslutter, la oss se på noen vanlige eksempler på å få et Not a Number (nan).
public class GenerateNaNValues {
static final float ZERO = 0;
public static void main (String[]args)
{
System.out.println("ZERO / ZERO = " + (ZERO / ZERO));
System.out.println("+INFINITY - INFINITY = " +
(Float.POSITIVE_INFINITY + Float.NEGATIVE_INFINITY));
System.out.println("-INFINITY * ZERO = " + (Float.NEGATIVE_INFINITY * ZERO));
System.out.println("+INFINITY * ZERO = " + (Float.POSITIVE_INFINITY * ZERO));
System.out.println("log10(-10) = " + Math.log(-10));
System.out.println("√-10 = " + Math.sqrt(-10));
System.out.println("NaN + 10 = " + (Float.NaN + 10));
System.out.println("NaN - 10 = " + (Float.NaN - 10));
System.out.println("NaN * 10 = " + (Float.NaN * 10));
System.out.println("NaN / 10 = " + (Float.NaN / 10));
System.out.println("NaN + NaN = " + (Float.NaN + Float.NaN));
System.out.println("NaN - NaN = " + (Float.NaN - Float.NaN));
System.out.println("NaN * NaN = " + (Float.NaN * Float.NaN));
System.out.println("NaN / NaN = " + (Float.NaN / Float.NaN));
}
}
Produksjon:
ZERO / ZERO = NaN
+INFINITY - INFINITY = NaN
-INFINITY * ZERO = NaN
+INFINITY * ZERO = NaN
log10(-10) = NaN
√-10 = NaN
NaN + 10 = NaN
NaN - 10 = NaN
NaN * 10 = NaN
NaN / 10 = NaN
NaN + NaN = NaN
NaN - NaN = NaN
NaN * NaN = NaN
NaN / NaN = NaN
GO TO FULL VERSION