I Java står "NaN" for "Not a Number". Det er ikke en type undtagelse, snarere overraskende er datatypen for NaN også et tal. Men ofte, når novice programmører får det utilsigtet, bruger de det yderligere i deres beregninger. Derfor kan inkompatible datatyper i Java, når de bruges sammen, forårsage en smid fejl. Det ses også almindeligvis, at ![NaN i Java - 1]()
Tag for eksempel et kig på følgende uddrag.
java.lang.ArithmeticException: / by zerodet betragtes som det samme som NaN. Java behandler dem begge forskelligt. Forvirrende nok? For din omfattende forståelse vil vi dissekere, hvordan disse er forskellige fra hinanden. I slutningen af denne artikel vil du lære om de mulige operationer, der ikke producerer et tal (nan), og nogle nemme måder at håndtere det på.
Hvad er NaN?
Så hvad er NaN? "NaN", som mange af jer har gættet, bruges til at repræsentere "Not a Number" i Java. Det er en speciel flydende kommaværdi til at angive overløb og fejl. Det genereres, når et flydende kommatal divideres med nul, eller hvis kvadratroden af et negativt tal beregnes.
Tag for eksempel et kig på følgende uddrag.
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
}
}
NaN
NaN
NaN
- At dividere et
float / doublenul med nul. - Under-roden af et negativt tal (Math.sqrt(-x)). I matematik resulterer det at tage kvadratroden af et negativt tal i et imaginært tal . Denne sag behandles ved at returnere NaN i Java.
- Hvis du tager mod af et tal med nul, returneres resten efter at have divideret en værdi med nul. Derfor returneres NaN.
Hvordan er NaN forskellig fra positiv og negativ uendelighed?
I henhold til IEEE 754-specifikationen er der tre specielle flydende komma- og dobbeltværdier til at håndtere grænsetilfældene:- Positiv uendelighed
- Negativ uendelighed
- NaN
Hvad er NaN()-metoden?
isNaN()er en af de grundlæggende metoder i Java til at kontrollere, om det er en NaN-værdi eller ej. Som vi diskuterede tre tilfælde ovenfor, er det tid til at teste, hvordan isNaN()-metoden skelner mellem +infinity , -infinity og NaN-værdier.
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());
}
}
+Infinity.IsNaN() = false
-Infinity.IsNaN() = false
NaN.IsNaN() = true
Hvordan sammenligner man NaN-værdier?
Hver NaN-værdi anses for at være særskilt. Det betyder, at ikke et enkelt NaN er lig med noget andet NaN. Ved dette princip, hvis du sammenligner en værdi med en anden, er resultatet altid negativt. Da NaN er uordnet, så en numerisk sammenligning, der involverer selv et enkelt NaN, returnerer falsk. Java giver Float.NaN og Double.NaN til konstante felter i begge klasser for at udføre sammenligninger. Vi kan skelne mellem disse i to separate scenarier:- Sandt: Kun i tilfælde af ulighed (!=)
- Falsk: 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 genererer man NaN-værdier?
Inden vi afslutter, lad os se på nogle almindelige eksempler på at 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));
}
}
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