Cara Mengonversi long ke int di Java

Pada artikel ini, kami akan menjelaskan cara mengonversi long ke int di Java dan menulis beberapa contoh kode. Karena long adalah tipe data yang lebih besar dari int , di sini kita harus menggunakan pengecoran tipe untuk konversi tersebut. Seperti yang mungkin sudah Anda ketahui, long dan int di Java adalah tipe data primitif. Itu berarti mereka bukan objek kelas. Semua Objek dan larik disimpan di Heap Space sementara tipe primitif seperti int dan long disimpan di memori Stack. Panjang dan int agak mirip. Integer berarti bilangan bulat, bisa positif, negatif, atau nol. Keduanya panjangdan int adalah tipe integer, jadi keduanya kompatibel. Masalahnya, tipe long berkisar antara -263 hingga 263 – 1, atau -9223372036854775808 hingga 9223372036854775807. Artinya, program Java mengalokasikan 64 bit untuk tipe long . Pada saat yang sama, tipe int menempati 32 bit, di mana Anda dapat memasukkan angka dari -231 до 231 - 1 atau, yang sama, dari -2147483648 hingga 2147483647. Ini berarti bahwa sejumlah tipe int dapat dengan mudah masuk ke dalam tipe panjang . Di Jawa, saat bekerja dengan primitif, konversi dari tipe yang lebih sempit ke tipe yang lebih luas dilakukan secara otomatis. Dengan cara lain, ini disebut pelebaran.

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

Di sini kita menugaskan int ke variabel panjang . Semuanya berjalan lancar, dalam rentang yang lebih besar, yang lebih kecil cocok dengan tenang dan kami tidak kehilangan apa pun kecuali ruang memori. Ngomong-ngomong, saat kita mendeklarasikan variabel bertipe long dan menentukan nilainya, lebih baik untuk menetapkan huruf l padanya, ini akan berguna saat kita bekerja dengan angka di luar rentang int .

long myVeryLong = 10000000000l;

Konversi panjang Java ke int

Sekarang mari kita kembali ke tugas utama artikel ini — Konversi panjang Java ke int . Masalahnya adalah sesuatu yang lebih besar tidak selalu cocok dengan sesuatu yang lebih kecil. Jadi di sini kita tidak bisa begitu saja memasukkan "lebih kecil" menjadi "lebih besar" secara otomatis di Jawa. Jika kita mencoba bertindak seperti pada contoh sebelumnya, tetapi sebaliknya:

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

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

Kompiler Java tidak akan membiarkan kami melakukan ini dan akan menimbulkan kesalahan. Jadi untuk operasi ini, kita perlu menggunakan apa yang disebut typecasting. Proses ini disebut konversi tipe penyempitan. Untuk mempersempit variabel, Anda perlu menentukan secara eksplisit jenis yang ingin Anda berikan nilainya. Berikut adalah contoh di mana kita akan mencoba untuk menempatkan satu "kecil" panjang ke int (yang harus cocok) dan dua angka panjang "besar" yang berada di luar kisaran 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);
   }
}

Kami telah memberi tahu kompiler bahwa kami ingin memasukkan nilai long ke dalam variabel int dan kami bertanggung jawab atas konsekuensi dari keputusan ini. Kompiler, melihat indikasi eksplisit dari tipe yang lebih sempit, melakukan konversi. Hasilnya, kami mendapatkan output: Yah, 16000 pasti yang kita harapkan, tapi mengapa minus di -2147483648? Dan apa artinya 1410065408 ini? Faktanya adalah angka-angka tersebut disimpan dalam variabel panjang , yang, seperti yang kita ingat, membutuhkan 64 bit. Kami mencoba memasukkan angka-angka ini ke dalam variabel int yang hanya dapat menyimpan 32 bit. Sebagai aturan, 32 sel ini akan berisi nol dan satu dari 32 bit pertama dari angka yang panjang , dan sisanya akan dibuang begitu saja. Oleh karena itu, jika angka aslinya tidak sesuai dengan 32 bit, maka bit yang tidak sesuai tersebut akan dibuang begitu saja. Itu sebabnya kami hanya memiliki angka yang benar 16000, karena membutuhkan kurang dari 32 bit.

Java 8 konversi panjang ke int

Di Java 8, kelas Math memiliki metode baru yang akan mengonversi long menjadi int . Ini dia:

Math.toIntExact(value);

Hal terbaik tentang metode ini adalah ia mengontrol panjang angka yang dikonversi, dan jika nilainya terlalu besar untuk dimasukkan ke dalam int , ia akan mengeluarkan pengecualian. Mari kita lihat cara kerjanya dalam contoh kita:

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

Outputnya adalah: Dengan demikian, program mencetak satu-satunya angka yang dikonversi dengan benar 16000, dan kemudian ketika mencoba mendorong angka di luar jangkauan 2147483648l ke dalam int , metode tersebut mengeluarkan pengecualian. Jadi kita tidak memiliki masalah membuang bit, seperti dalam kasus Java klasik konversi long ke int .