Sa Java, ang "NaN" ay nangangahulugang "Not a Number". Ito ay hindi isang uri ng pagbubukod, sa halip nakakagulat, ang datatype ng NaN ay isang numero din. Ngunit madalas kapag hindi sinasadyang nakuha ng mga baguhang programmer, mas ginagamit nila ito sa kanilang mga kalkulasyon. Samakatuwid, ang mga hindi tugmang uri ng data sa Java kapag ginamit nang magkasama ay maaaring magdulot ng isang natapon na error. Karaniwan din itong nakikita na
Halimbawa, tingnan ang sumusunod na snippet.
java.lang.ArithmeticException: / by zero
itinuturing na kapareho ng NaN. Gayunpaman, naiiba ang pagtrato sa kanila ng Java. Nakakapagtaka? Para sa iyong komprehensibong pag-unawa, hihiwalayin namin kung paano ito naiiba sa isa't isa. Sa pagtatapos ng artikulong ito matututunan mo ang tungkol sa mga posibleng pagpapatakbo na hindi gumagawa ng numero (nan), at ilang madaling paraan upang mahawakan ito.
Ano ang NaN?
Kaya, ano ang NaN? Ang "NaN" gaya ng nahulaan ng marami sa inyo, ay ginagamit upang kumatawan sa "Not a Number" sa Java. Ito ay isang espesyal na halaga ng floating point upang tukuyin ang mga overflow at error. Ito ay nabuo kapag ang isang floating point na numero ay hinati sa zero o kung ang square root ng isang negatibong numero ay nakalkula.
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
}
}
Output
NaN
NaN
NaN
Sa snippet sa itaas, maaari mong obserbahan na ang NaN ay ginawa bilang resulta ng 3 simpleng operasyon:
- Paghahati ng
float / double
zero na may zero. - Pagkuha ng under-root ng isang negatibong numero (Math.sqrt(-x)). Sa matematika, ang pagkuha ng square root ng isang negatibong numero ay nagreresulta sa isang haka-haka na numero . Ang kasong ito ay hinarap sa pamamagitan ng pagbabalik ng NaN sa Java.
- Ang pagkuha ng mod ng isang numero na may zero, ay ibabalik ang natitira pagkatapos hatiin ang isang halaga sa zero. Samakatuwid, ibinalik ang NaN.
Paano Naiiba ang NaN sa Positive at Negative Infinity?
Ayon sa detalye ng IEEE 754, mayroong tatlong espesyal na floating-point at dobleng halaga upang pangasiwaan ang mga boundary case:- Positibong infinity
- Negatibong infinity
- NaN
Ano ang NaN() Method?
isNaN()
ay isa sa mga pangunahing pamamaraan sa Java upang suriin kung ito ay isang halaga ng NaN o hindi. Tulad ng tinalakay namin ang tatlong kaso sa itaas, oras na upang subukan kung paano naiiba ang isNaN() method sa pagitan ng +infinity , -infinity at NaN values.
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());
}
}
Output
+Infinity.IsNaN() = false
-Infinity.IsNaN() = false
NaN.IsNaN() = true
Paano Ihambing ang mga Halaga ng NaN?
Ang bawat halaga ng NaN ay itinuturing na naiiba. Nangangahulugan ito, hindi isang solong NaN ang katumbas ng anumang iba pang NaN. Sa pamamagitan ng prinsipyong ito, Kung ihahambing mo ang isang halaga sa isa pa ang resulta ay palaging negatibo. Dahil, ang NaN ay hindi nakaayos, kaya ang isang numeric na paghahambing na kinasasangkutan ng kahit isang solong NaN ay nagbabalik ng false. Nagbibigay ang Java ng Float.NaN at Double.NaN para sa mga pare-parehong field sa parehong klase upang maisagawa ang mga paghahambing. Maaari nating pag-iba-ibahin ang mga ito sa dalawang magkahiwalay na senaryo:- Tama: Sa kaso lang ng In-equality (!=)
- Mali: Para sa lahat ng operand ng paghahambing (==, <=, >=, <, >)
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
}
}
Paano Bumuo ng Mga Halaga ng NaN?
Bago magtapos, tingnan natin ang ilang karaniwang halimbawa ng pagkuha ng 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));
}
}
Output:
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