En Java, "NaN" significa "No es un número". No es un tipo de excepción, más bien sorprendentemente, el tipo de datos de NaN también es un número. Pero a menudo, cuando los programadores novatos lo obtienen sin querer, lo usan más en sus cálculos. Por lo tanto, los tipos de datos incompatibles en Java cuando se usan juntos pueden causar un error. También se ve comúnmente que
Por ejemplo, eche un vistazo al siguiente fragmento.
java.lang.ArithmeticException: / by zero
se considera lo mismo que NaN. Sin embargo, Java los trata a ambos de manera diferente. ¿Lo suficientemente desconcertante? Para su comprensión integral, analizaremos en qué se diferencian entre sí. Al final de este artículo, aprenderá sobre las posibles operaciones que producen no un número (nan) y algunas formas fáciles de manejarlas.
¿Qué es NaN?
Entonces, ¿qué es NaN? "NaN", como muchos de ustedes habrán adivinado, se usa para representar "No es un número" en Java. Es un valor de punto flotante especial para denotar desbordamientos y errores. Se genera cuando un número de punto flotante se divide por cero o si se calcula la raíz cuadrada de un número negativo.
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
}
}
Producción
NaN
NaN
NaN
En el fragmento anterior, puede observar que NaN se produce como resultado de 3 operaciones simples:
- Dividir un
float / double
cero con cero. - Tomando la raíz de un número negativo (Math.sqrt(-x)). En matemáticas, sacar la raíz cuadrada de un número negativo da como resultado un número imaginario . Este caso se trata devolviendo NaN en Java.
- Tomando mod de un número con cero, devolverá el resto después de dividir un valor por cero. Por lo tanto, se devuelve NaN.
¿En qué se diferencia NaN del infinito positivo y negativo?
De acuerdo con la especificación IEEE 754, hay tres valores dobles y de punto flotante especiales para manejar los casos límite:- infinito positivo
- infinito negativo
- Yaya
¿Qué es el método NaN()?
isNaN()
es uno de los métodos básicos en Java para verificar si es un valor NaN o no. Como discutimos los tres casos anteriores, es hora de probar cómo el método isNaN() diferencia entre los valores +infinity , -infinity y NaN.
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());
}
}
Producción
+Infinity.IsNaN() = false
-Infinity.IsNaN() = false
NaN.IsNaN() = true
¿Cómo comparar los valores de NaN?
Cada valor de NaN se considera distinto. Esto significa que ningún NaN es igual a ningún otro NaN. Por este principio, si comparas un valor con otro, el resultado siempre es negativo. Dado que NaN no está ordenado, una comparación numérica que involucre incluso un solo NaN devuelve falso. Java proporciona Float.NaN y Double.NaN para campos constantes en ambas clases para realizar comparaciones. Podemos diferenciarlos en dos escenarios separados:- Verdadero: Solo en caso de Desigualdad (!=)
- Falso: para todos los operandos de comparación (==, <=, >=, <, >)
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
}
}
¿Cómo generar valores NaN?
Antes de terminar, veamos algunos ejemplos comunes de obtener un No es un número (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));
}
}
Producción:
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