Java Float Keyword

Sa ilang mga punto sa pag-unlad ng teknolohiya ng pag-compute, naging malinaw na ang mga central processing unit ay nangangailangan ng mga hardware device upang iproseso ang mga numero ng floating point. Ngayon, lahat ng mga arkitektura ng computer ay maaaring gumana nang epektibo sa mga naturang numero. Siyempre, sa mga programming language, hindi mo rin magagawa nang wala ang kaukulang mga uri ng data. Mayroong dalawang uri ng data ng floating point sa Java: float at double. Ang Java Float na keyword ay tumutukoy sa isang tunay na numero na sumasakop sa 32 bits sa memorya. Pag-uusapan natin ang tungkol sa mga naturang numero sa artikulong ito.

Mga numero ng floating point. Paano nakaimbak ang mga tunay na numero sa isang computer?

Upang mag-imbak ng mga tunay na numero sa memorya ng computer, ang isang tiyak na bilang ng mga bit ay inilalaan. Ang isang tunay na numero ay iniimbak bilang isang tanda (plus o minus), mantis, at exponent. Ano ang mantissa at exponent ay pinakamahusay na ipinaliwanag sa isang halimbawa. Ang tinatayang masa ng buwan ay 7* 1022. Narito ang 7 ay ang mantis, sa 22 ang exponent. Kapag nagpapakita ng malaki o kabaligtaran, napakaliit na mga numero sa screen, makakakita ka ng entry tulad ng 7E22. Ito ang numero ng floating point, at ang 7 dito ay ang mantis, at ang 22 ay ang exponent o kapangyarihan ng 10. Ang notasyong ito ay tinatawag na exponential notation.

Java float Keyword at Java Double Keyword

Ang mga float value (Floating point number o real number) sa Java ay kinakatawan ng mga uri ng float at double . Ang mga keyword na ito ang ginagamit upang mag-imbak ng mga halaga hanggang sa isang tiyak na tanda pagkatapos ng decimal point. double ay mga numero na may dobleng katumpakan, mas malapit hangga't maaari sa mga halaga na ibinigay o nakuha bilang resulta ng mga kalkulasyon. Ginagamit ang Java Double para sa anumang mathematical na kalkulasyon (square root, sine, cosine, ..), pati na rin para sa lahat ng kalkulasyon kung saan mahalaga ang isang tiyak na katumpakan. Ang uri ng float ng data ay ginagamit para sa isang hindi gaanong tumpak na uri ng floating point. Ito ay ginagamit na napakabihirang upang makatipid ng memorya. Sa ibaba, mayroon kaming isang talahanayan na may pangunahing impormasyon tungkol sa float at double, pati na rin ang kanilang mga pagkakaiba. Kaya ang Float na keyword ay nangangahulugang isang numero, isang solong katumpakan na halaga na tumatagal ng 32 bits o 4 na byte sa memorya. Sa ilang mga processor, ang pagtatrabaho sa mga naturang numero ay mas mabilis, at, tulad ng nabanggit na, kumukuha sila ng mas kaunting espasyo kung ihahambing sa mga numero na may dobleng katumpakan. Gayunpaman, imposibleng sabihin nang walang pag-aalinlangan sa bilis. Sabihin natin na ang ilang modernong processor ay nagpoproseso ng eksaktong dobleng mga numero ng katumpakan nang mas mabilis.

Java Float at Dobleng Deklarasyon

Maaari kang magdeklara ng dobleng bilang ng uri sa parehong paraan tulad ng mga bilang ng iba pang uri:

double myDouble = 2.7;

Gayunpaman, kung kinakatawan mo ang isang floating point na numero sa ganitong paraan, hihilingin sa iyo ng compiler na baguhin ang uri ng numero upang doble. Narito ang isang maling halimbawa ng float variable:

public class FloatExample {
   public static void main(String[] args) {
//double and float variables
       double myDouble = 2.7;
       float myFloat = 3.14;
   }
}

Narito ang mangyayari kung patakbuhin mo ang program na ito:

Error:(4, 25) java: incompatible types: possible lossy conversion from double to float

Ang katotohanan ay hindi kanais-nais na gumamit ng mga numero ng float, at dapat itong gawin lamang upang makatipid ng memorya. Ang lahat ng tunay na fractional na numero sa Java ay Double bilang default, at binibigyang-diin din ito ng syntax ng wika. Kung gusto mo talagang magtrabaho kasama ang uri ng float, kailangan mong tahasan itong tukuyin sa isang f na nagtatapos sa numero.

public class FloatExample {
   public static void main(String[] args) {
//double and float variables
       double myDouble = 2.7;
       float myFloat = 3.14f;
   }
}

Sa pamamagitan ng paraan, ang float at double number ay maaaring isulat sa exponential form.

float myFloat2 = 2E22f;
double myDouble2 = 3e10;

Kung gumamit ka ng sapat na malalaking numero sa kanilang "normal" na representasyon, agad na ipapakita ng Java ang mga ito sa exponential form. Magkaroon tayo ng isang halimbawa:

public class FloatExample {
   public static void main(String[] args) {
//float variables
               float myFloatNumber1=2182818284590.45f;
               float myFloatNumber2=19822612787260.141592181f;
               System.out.println("myFloatNumber1 = " + myFloatNumber1);
               System.out.println("myFloatNumber2 = " + myFloatNumber2);
       System.out.println("myFloatNumber1 + myFloatNumber2 = " + myFloatNumber1 + myFloatNumber2);
           }
       }

Ang resulta ng gawain ng programang ito ay narito:

Halimbawa ng mga espesyal na float at dobleng numero

Mayroong tatlong espesyal na numero ng floating point sa wikang Java, na ginagamit upang ipahiwatig ang mga overflow at error. Nandito na sila:

• Ang positibong infinity ay ang resulta ng paghahati ng positibong numero sa 0. Kinakatawan ng mga constant na Double.POSITIVE_INFINITY at Float.POSITIVE_INFINITY .

• Ang negatibong infinity ay ang resulta ng paghahati ng negatibong numero sa 0. Kinakatawan ng Double.NEGATIVE_INFINITY at Float.NEGATIVE_INFINITY constants.

• Ang NaN (hindi isang numero) ay kumakatawan sa pagkalkula ng 0/0 o pagkuha ng square root ng isang negatibong numero. Kinakatawan ng mga constant na Double.NaN at Float.NAN .

Narito ang isang halimbawa ng paggamit ng mga espesyal na numero ng floating point:

public class FloatExample {
   public static void main(String[] args) {
       int myInt = 1;
       float zero = 0.0f;
       double negZero = -0.0;
       double negativeInfinity = Double.NEGATIVE_INFINITY;
       double positiveInfinity = Float.POSITIVE_INFINITY;

       System.out.println(myInt / zero);
       System.out.println(myInt / negZero);
       System.out.println(zero == negZero);
       System.out.println(negativeInfinity * 0);
       System.out.println(positiveInfinity+negativeInfinity);

   }
}

Ang resulta ay:

Sapat ba ang Double precision?

Sa katunayan, sa kabila ng dobleng katumpakan ng Double type, ang paggamit ng mga floating point na numero, halimbawa, sa mga kalkulasyon sa pananalapi, ay hindi ang pinakamagandang ideya dahil ang mga error sa pag-round ay hindi katanggap-tanggap. Kaya, subukang ipakita ang output ng sumusunod na programa sa screen.

public class FloatExample {
   public static void main(String[] args) {
       System.out. println( "2.0 - 1.1 = " + (2.0 - 1.1));
   }
}

Makukuha mo ang sumusunod na resulta: Magiging lohikal na ipagpalagay na ang resulta ay magiging 0.9. Gayunpaman, ang mga naturang error ay medyo karaniwan at nauugnay sa panloob na binary na representasyon ng mga numero. Hindi namin, halimbawa, kinakatawan ang eksaktong halaga ng ⅓ bilang isang decimal fraction; siyempre, may mga katulad na paghihigpit sa binary system. Kung ang gawain ay nangangailangan ng pag-aalis ng mga error sa pag-ikot, ang Java ay may BigDecimal na klase para dito.