Hogyan lehet hosszút int-re konvertálni Java-ban

Ebben a cikkben elmagyarázzuk, hogyan konvertálhatjuk a long- ot int -re Java nyelven, és írunk néhány kódpéldát. Mivel a long nagyobb adattípus, mint az int , itt típusöntést kell használnunk az ilyen átalakításhoz. Amint azt valószínűleg már tudja, a long és az int is primitív adattípusok a Java-ban. Ez azt jelenti, hogy nem osztályobjektumok. Minden objektum és tömb a kupactérben, míg a primitív típusok, például az int és a long a verem memóriájában tárolódnak. A long és az int némileg hasonlóak. Az egész szám egész számot jelent, amely lehet pozitív, negatív vagy nulla. Mindkettő hosszúés az int egész típusúak, tehát bizonyos értelemben kompatibilisek. A probléma az, hogy a hosszú típus -263 és 263 - 1, vagy -9223372036854775808 és 9223372036854775807 között van. Vagyis a Java program 64 bitet foglal le egy hosszú típushoz. Ugyanakkor az int típus 32 bitet foglal el, amelybe -231-től 231-ig - 1-ig, vagy -2147483648-tól 2147483647-ig terjedő számok írhatók. Ez azt jelenti, hogy tetszőleges számú int típus könnyen belefér egy hosszú típus. A Java-ban a primitívekkel végzett munka során a szűkebb típusról a szélesebb típusra történő átalakítás automatikus. Más módon kiszélesedésnek nevezik.

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

Itt egy int-et rendelünk egy hosszú változóhoz. Minden gördülékenyen ment, nagyobb tartományban, csendesen elfér egy kisebb és a memóriaterületen kívül semmit nem veszítünk. Amúgy, amikor egy változót long típusúnak deklarálunk és az értékét definiáljuk, akkor jobb, ha l betűt rendelünk hozzá, ez jól jön, ha int tartományon kívüli számokkal dolgozunk.

long myVeryLong = 10000000000l;

Java hosszú int konverzió

Most térjünk vissza a cikk fő feladatához – a Java long -to int konverziójához. A probléma az, hogy valami nagyobb nem mindig fér bele valami kisebbbe. Tehát itt nem tehetjük meg a „kisebbet” automatikusan „nagyobb”-ba a Java-ban. Ha megpróbálunk úgy járni, mint az előző példában, de fordítva:

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

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

A Java fordító egyszerűen nem engedi ezt megtenni, és hibát dob. Tehát ehhez a művelethez az úgynevezett typecasting-ot kell használnunk. Ezt a folyamatot szűkítő típusú konverziónak nevezik. Egy változó szűkítéséhez kifejezetten meg kell adnia azt a típust, amelyre át szeretné adni az értéket. Íme egy példa, ahol megpróbálunk egy „kis” hosszút int -be tenni (amelynek bele kell férnie), és két „nagy” hosszú számot, amelyek kívül esnek az int tartományon.

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);
   }
}

Értesítettük a fordítót, hogy a long értéket egy int változóba akarjuk tenni, és felelősséggel tartozunk ennek a döntésnek a következményeiért. A fordító, látva egy szűkebb típus kifejezett jelzését, végrehajtja az átalakítást. Ennek eredményeként a következő kimenetet kapjuk: Nos, 16000 határozottan az, amit vártunk, de miért van mínusz a -2147483648-ban? És mit jelent ez a 1410065408? A helyzet az, hogy az ilyen számokat egy hosszú változóban tárolták , amely, mint emlékszünk, 64 bitet vesz igénybe. Megpróbáljuk ezeket a számokat egy int változóba helyezni, amely csak 32 bitet tud tárolni. Általában ez a 32 cella nullákat és egyeseket tartalmaz a hosszú szám első 32 bitjéből, a többit pedig egyszerűen el kell dobni. Ezért, ha az eredeti szám nem fér bele 32 bitbe, akkor azokat a biteket, amelyek nem férnek bele, egyszerűen el kell dobni. Ezért csak a 16000-es helyes számunk van, mivel kevesebb mint 32 bitet foglal.

Java 8 hosszú int konverzió

A Java 8-ban a Math osztály új metódussal rendelkezik, amely a long-ot int -re konvertálja . Itt van:

Math.toIntExact(value);

A legjobb ebben a módszerben az, hogy szabályozza a konvertált szám hosszát, és ha az érték túl nagy ahhoz, hogy beleférjen egy int -be , kivételt dob. Nézzük meg, hogyan működik ez a példánkban:

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));
   }
}

A kimenet a következő: Így a program az egyetlen helyesen konvertált 16000-es számot nyomtatta ki, majd amikor a 2147483648l tartományon kívüli számot próbálta betolni az int -be , a metódus kivételt dobott. Így nincs gondunk az eldobott bitekkel, mint a klasszikus Java long to int konverziónál.