Bagaimana untuk Menukar panjang kepada int dalam Java

Dalam artikel ini, kami akan menerangkan cara menukar panjang kepada int dalam Java dan menulis beberapa contoh kod. Memandangkan long ialah jenis data yang lebih besar daripada int , di sini kita harus menggunakan penghantaran jenis untuk penukaran tersebut. Seperti yang anda mungkin sudah tahu kedua-dua long dan int dalam Java adalah jenis data primitif. Ini bermakna mereka bukan objek kelas. Semua Objek dan tatasusunan disimpan dalam Heap Space manakala jenis primitif seperti int dan long disimpan dalam memori Stack. Panjang dan int agak serupa. Integer bermaksud nombor bulat, yang boleh menjadi positif, negatif, atau sifar. Kedua-duanya panjangdan int ialah jenis integer, jadi ia serasi dalam sesuatu cara. Masalahnya ialah, jenis panjang berjulat dari -263 hingga 263 – 1, atau -9223372036854775808 hingga 9223372036854775807. Iaitu, program Java memperuntukkan 64 bit untuk jenis yang panjang . Pada masa yang sama, jenis int menduduki 32 bit, di mana anda boleh meletakkan nombor dari -231 hingga 231 - 1 atau, yang sama, dari -2147483648 hingga 2147483647. Ini bermakna sebarang nombor jenis int boleh dimuatkan dengan mudah ke dalam jenis panjang . Di Jawa, apabila bekerja dengan primitif, penukaran daripada jenis yang lebih sempit kepada jenis yang lebih luas adalah automatik. Dalam cara lain, ia dipanggil pelebaran.

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

Di sini kami memberikan int kepada pembolehubah panjang . Semuanya berjalan lancar, dalam julat yang lebih besar, yang lebih kecil sesuai dengan senyap dan kami tidak kehilangan apa-apa kecuali ruang ingatan. Dengan cara ini, apabila kita mengisytiharkan pembolehubah jenis panjang dan menentukan nilainya, adalah lebih baik untuk menetapkan huruf l kepadanya, ini akan berguna apabila kita bekerja dengan nombor di luar julat int .

long myVeryLong = 10000000000l;

Penukaran Java long ke int

Sekarang mari kita kembali kepada tugas utama artikel ini — penukaran Java long ke int . Masalahnya ialah sesuatu yang lebih besar tidak selalunya sesuai dengan sesuatu yang lebih kecil. Jadi di sini kita tidak boleh meletakkan "lebih kecil" kepada "lebih besar" secara automatik di Jawa. Jika kita cuba bertindak seperti dalam contoh sebelumnya, tetapi sebaliknya:

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

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

Pengkompil Java tidak akan membenarkan kami melakukan ini dan akan membuang ralat. Jadi untuk operasi ini, kita perlu menggunakan apa yang dipanggil typecasting. Proses ini dipanggil penukaran jenis penyempitan. Untuk mengecilkan pembolehubah, anda perlu menyatakan secara eksplisit jenis yang anda ingin hantarkan nilai anda. Berikut ialah contoh di mana kita akan cuba meletakkan satu "kecil" panjang kepada int (yang sepatutnya muat) dan dua nombor panjang "besar" yang berada di luar julat 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 memberitahu pengkompil bahawa kami ingin meletakkan nilai panjang ke dalam pembolehubah int dan kami bertanggungjawab atas akibat keputusan ini. Pengkompil, melihat petunjuk eksplisit jenis yang lebih sempit, melakukan penukaran. Akibatnya, kami mendapat output: Nah, 16000 sudah pasti apa yang kita jangkakan untuk dilihat, tetapi mengapa tolak dalam -2147483648? Dan apakah maksud 1410065408 ini? Hakikatnya ialah nombor sedemikian disimpan dalam pembolehubah panjang , yang, seperti yang kita ingat, mengambil 64 bit. Kami cuba memasukkan nombor ini ke dalam pembolehubah int yang hanya boleh menyimpan 32 bit. Sebagai peraturan, 32 sel ini akan mengandungi sifar dan satu daripada 32 bit pertama nombor panjang , dan selebihnya akan dibuang begitu sahaja. Oleh itu, jika nombor asal tidak sesuai dengan 32 bit, maka bit yang tidak sesuai dibuang begitu sahaja. Itulah sebabnya kami hanya mempunyai nombor yang betul 16000, kerana ia memerlukan kurang daripada 32 bit.

Penukaran Java 8 panjang kepada int

Dalam Java 8, kelas Matematik mempunyai kaedah baharu yang akan menukar long kepada int . Ini dia:

Math.toIntExact(value);

Perkara terbaik tentang kaedah ini ialah ia mengawal panjang nombor yang ditukar dan jika nilainya terlalu besar untuk dimuatkan ke dalam int , ia akan membuang pengecualian. Mari lihat bagaimana ini berfungsi dalam contoh kami:

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 ialah: Oleh itu, program mencetak satu-satunya nombor yang ditukar dengan betul 16000, dan kemudian apabila cuba menolak nombor luar julat 2147483648l ke dalam int , kaedah itu mengeluarkan pengecualian. Jadi kami tidak mempunyai masalah bit yang dibuang, seperti dalam kes penukaran Java panjang kepada int klasik .