Paano i-convert ang mahaba sa int sa Java

Sa artikulong ito, ipapaliwanag namin kung paano i-convert ang long sa int sa Java at magsulat ng ilang mga halimbawa ng code. Dahil ang long ay isang mas malaking uri ng data kaysa sa int , dito dapat nating gamitin ang type casting para sa naturang conversion. Tulad ng malamang na alam mo na ang parehong mahaba at int sa Java ay mga primitive na uri ng data. Ibig sabihin, hindi sila bagay sa klase. Ang lahat ng Objects at arrays ay naka-store sa Heap Space habang ang mga primitive na uri gaya ng int at long ay naka-store sa Stack memory. Mahaba at int ay medyo magkatulad. Ang ibig sabihin ng integer ay buong numero, na maaaring positibo, negatibo, o zero. Parehong mahabaat ang int ay mga uri ng integer, kaya magkatugma ang mga ito sa isang paraan. Ang problema ay, na ang mahabang uri ay umaabot mula -263 hanggang 263 – 1, o -9223372036854775808 hanggang 9223372036854775807. Iyon ay, ang Java program ay naglalaan ng 64 bits para sa isang mahabang uri. Kasabay nito, ang uri ng int ay sumasakop ng 32 bits, kung saan maaari kang maglagay ng mga numero mula -231 hanggang 231 - 1 o, na pareho, mula -2147483648 hanggang 2147483647. Nangangahulugan ito na ang anumang bilang ng uri ng int ay madaling magkasya sa isang mahabang uri. Sa Java, kapag nagtatrabaho sa mga primitive, ang conversion mula sa mas makitid na uri patungo sa mas malawak na uri ay awtomatiko. Sa ibang paraan, ito ay tinatawag na widening.

int myInt= 18;
long myLong= 16000;
       myLong = myInt;

Dito kami ay nagtatalaga ng isang int sa isang mahabang variable. Naging maayos ang lahat, sa mas malaking hanay, tahimik na umaangkop ang isang mas maliit at wala kaming mawawala maliban sa espasyo ng memorya. Sa pamamagitan ng paraan, kapag ipinahayag namin ang isang variable ng uri ng haba at tinukoy ang halaga nito, mas mahusay na italaga ang titik l dito, ito ay magiging kapaki-pakinabang kapag nagtatrabaho kami sa mga numero sa labas ng int range.

long myVeryLong = 10000000000l;

Java long to int conversion

Ngayon ay bumalik tayo sa pangunahing gawain ng artikulong ito — Java long to int conversion. Ang problema ay ang isang bagay na mas malaki ay hindi palaging magkasya sa isang bagay na mas maliit. Kaya dito hindi lang natin mailalagay ang "mas maliit" sa "mas malaki" nang awtomatiko sa Java. Kung susubukan naming kumilos tulad ng sa nakaraang halimbawa, ngunit kabaligtaran:

//example without typecasting…nice trying!
public static void main(String[] args) {

int myInt= 18;
long myLong= 16000;
       myInt = myLong;
}

Hindi lang kami hahayaan ng Java compiler na gawin ito at magtatapon ng error. Kaya para sa operasyong ito, kailangan nating gumamit ng tinatawag na typecasting. Ang prosesong ito ay tinatawag na narrowing type conversion. Upang paliitin ang isang variable, kailangan mong tahasang tukuyin ang uri kung saan mo gustong i-cast ang iyong halaga. Narito ang isang halimbawa kung saan susubukan nating ilagay ang isang "maliit" na haba sa int (na dapat magkasya) at dalawang "malaki" na mahabang numero na wala sa hanay ng int .

public class longToInt {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long myVeryLong = 2147483648l;//l in the end means ‘long’
       long myVeryLong = 10000000000l;

       myInt = (int) myLong;
       System.out.println(myInt);
       myInt = (int) oneMoreLong;
       System.out.println(myInt);
       myInt = (int) myVeryLong;
       System.out.println(myInt);
   }
}

Naabisuhan namin ang compiler na gusto naming ilagay ang mahabang halaga sa isang int variable at kami ang may pananagutan sa mga kahihinatnan ng desisyong ito. Ang compiler, na nakikita ang isang tahasang indikasyon ng isang mas makitid na uri, ay nagsasagawa ng conversion. Bilang resulta, nakukuha namin ang output: Well, 16000 talaga ang inaasahan naming makita, pero bakit nasa -2147483648 ang minus? At ano ang ibig sabihin ng 1410065408 na ito? Ang katotohanan ay ang mga naturang numero ay naka-imbak sa isang mahabang variable, na, tulad ng naaalala natin, ay tumatagal ng 64 bits. Sinusubukan naming ilagay ang mga numerong ito sa isang int variable na maaari lamang mag-imbak ng 32 bits. Bilang isang patakaran, ang 32 cell na ito ay maglalaman ng mga zero at isa mula sa unang 32 bit ng mahabang numero, at ang iba ay itatapon na lang. Samakatuwid, kung ang orihinal na numero ay hindi magkasya sa 32 bits, ang mga piraso na hindi magkasya ay itatapon lamang. Iyon ang dahilan kung bakit mayroon lamang tayong tamang numero na 16000, dahil ito ay tumatagal ng mas mababa sa 32 bits.

Java 8 long to int conversion

Sa Java 8, ang klase ng Math ay may bagong pamamaraan na magko-convert ng matagal sa int . Heto na:

Math.toIntExact(value);

Ang pinakamagandang bagay tungkol sa pamamaraang ito ay kinokontrol nito ang haba ng na-convert na numero, at kung ang halaga ay masyadong malaki upang magkasya sa isang int , maglalagay ito ng exception. Tingnan natin kung paano ito gumagana sa aming halimbawa:

public class intToLong {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long oneMoreLong = 2147483648l;
       long myVeryLong = 10000000000l;

       System.out.println(Math.toIntExact(myLong));
       int y = Math.toIntExact(oneMoreLong);
       System.out.println(oneMoreLong);
       System.out.println(Math.toIntExact(myVeryLong));
   }
}

Ang output ay: Kaya, ang programa ay naka-print ang tanging tama na na-convert na numero 16000, at pagkatapos ay kapag sinusubukang itulak ang out-of-range na numero 2147483648l sa int , ang pamamaraan ay naghagis ng isang pagbubukod. Kaya't wala kaming problema sa mga itinapon na piraso, tulad ng sa kaso ng classic na Java na matagal hanggang int na conversion.