Penukaran Primitif Java

1. Pengenalan

Java adalah bahasa yang ditaip yang bermaksud menggunakan konsep jenis. Terdapat dua kumpulan jenis yang berbeza:

  1. jenis data primitif
  2. jenis data abstrak.

Dalam artikel ini, kita akan menumpukan pada penukaran jenis primitif.

2. Gambaran Keseluruhan Primitif

Perkara pertama yang harus kita ketahui ialah jenis nilai apa yang boleh digunakan dengan jenis primitif. Terdapat lapan jenis primitif iaitu:

  • bait - 8 bit dan ditandatangani

  • pendek - 16 bit dan ditandatangani

  • char - 16 bit dan tidak ditandatangani, sehingga mungkin mewakili watak Unicode

  • int - 32 bit dan ditandatangani

  • panjang - 64 bit dan ditandatangani

  • apungan - 32 bit dan ditandatangani

  • dua kali ganda - 64 bit dan ditandatangani

  • boolean - ia tidak berangka, mungkin hanya mempunyainilai benar atau salah

Ini tidak dimaksudkan untuk menjadi perbincangan yang luas mengenai primitif dan kami akan membincangkan lebih banyak perinciannya seperti yang diperlukan semasa perbincangan.

3. Peningkatan Primitif Penukaran

Apabila kita perlu menukar dari primitif yang lebih sederhana atau lebih kecil daripada jenis tujuan, kita tidak perlu menggunakan notasi khas untuk itu:

int myInt = 127; long myLong = myInt;

Semasa penukaran melebar, nilai primitif yang lebih kecil diletakkan di atas bekas yang lebih besar, yang bermaksud bahawa semua ruang tambahan, di sebelah kiri nilai, dipenuhi dengan angka nol. Ini juga boleh digunakan untuk pergi dari kumpulan integer ke titik terapung:

float myFloat = myLong; double myDouble = myLong;

Ini mungkin kerana bergerak ke primitif yang lebih luas tidak kehilangan maklumat.

4. Penukaran Primitif yang Menyempit

Kadang-kadang kita perlu memasukkan nilai yang lebih besar daripada jenis yang digunakan dalam deklarasi pemboleh ubah. Ini boleh mengakibatkan kehilangan maklumat kerana sebilangan bait harus dibuang.

Dalam kes ini, kita harus secara eksplisit menyatakan bahawa kita mengetahui keadaannya dan kita setuju dengan itu, dengan menggunakan pemeran:

int myInt = (int) myDouble; byte myByte = (byte) myInt;

5. Penukaran Primitif yang Meluas dan Menyempit

Keadaan ini berlaku dalam kes yang sangat spesifik ketika kita ingin menukar dari bait ke char . Penukaran pertama adalah pelebaran bait ke int dan kemudian dari int ia disempitkan menjadi arang .

Contoh akan menjelaskan perkara ini:

byte myLargeValueByte = (byte) 130; //0b10000010 -126

Perwakilan binari 130 adalah sama untuk -126, perbezaannya adalah tafsiran bit isyarat. Sekarang mari kita menukar dari bait ke char :

char myLargeValueChar = (char) myLargeValueByte; //0b11111111 10000010 unsigned value int myLargeValueInt = myLargeValueChar; //0b11111111 10000010 65410

The char perwakilan adalah nilai Unicode, tetapi menukar kepada int menunjukkan kepada kita nilai yang sangat besar yang mempunyai yang lebih rendah 8 bit sama seperti -126.

Sekiranya kita menukarnya semula menjadi bait, kita mendapat:

byte myOtherByte = (byte) myLargeValueInt; //0b10000010 -126

Nilai asal yang kami gunakan. Sekiranya keseluruhan kod bermula dengan char , nilainya akan berbeza:

char myLargeValueChar2 = 130; //This is an int not a byte! //0b 00000000 10000010 unsigned value int myLargeValueInt2 = myLargeValueChar2; //0b00000000 10000010 130 byte myOtherByte2 = (byte) myLargeValueInt2; //0b10000010 -126

Walaupun representasi byte adalah sama, iaitu -126, representasi char memberi kita dua watak yang berbeza.

6. Penukaran Boxing / Unboxing

Di Jawa, kami memiliki Kelas Pembungkus untuk setiap jenis primitif, ini adalah cara yang cerdas untuk menyediakan programmer dengan kaedah pemprosesan yang berguna, tanpa overhead untuk menjadikan semuanya sebagai rujukan objek kelas berat. Sejak Java 1.5 kemampuan untuk secara automatik mengubah ke / dari primitif ke objek dan belakang disertakan dan dicapai dengan atribusi sederhana:

Integer myIntegerReference = myInt; int myOtherInt = myIntegerReference;

7. Penukaran Rentetan

Semua jenis primitif boleh ditukar ke String melalui Wrapper Classes mereka, yang menggantikan kaedah toString () :

String myString = myIntegerReference.toString();

Sekiranya kita perlu kembali ke jenis primitif, kita perlu menggunakan kaedah parse yang ditentukan oleh Wrapper Class yang sesuai:

byte myNewByte = Byte.parseByte(myString); short myNewShort = Short.parseShort(myString); int myNewInt = Integer.parseInt(myString); long myNewLong = Long.parseLong(myString); float myNewFloat = Float.parseFloat(myString); double myNewDouble = Double.parseDouble(myString); 
boolean myNewBoolean = Boolean.parseBoolean(myString);

The only exception here is the Character Class because a String is made of chars anyway, this way, considering that probably the String is made of a single char, we can use the charAt() method of the String class:

char myNewChar = myString.charAt(0);

8. Numeric Promotions

To execute a binary operation, it is necessary that both operands are compatible in terms of size.

There is a set of simple rules that apply:

  1. If one of the operands is a double, the other is promoted to double
  2. Otherwise, if one of the operands is a float, the other is promoted to float
  3. Jika tidak, jika salah satu operan panjang , yang lain dipromosikan menjadi panjang
  4. Jika tidak, kedua-duanya dianggap int

Mari lihat contoh:

byte op1 = 4; byte op2 = 5; byte myResultingByte = (byte) (op1 + op2);

Kedua-dua operan dipromosikan ke int dan hasilnya mesti diturunkan ke bait lagi.

9. Kesimpulannya

Penukaran antara jenis adalah tugas yang sangat biasa dalam aktiviti pengaturcaraan harian. Terdapat sekumpulan peraturan yang mengatur cara bahasa yang ditaip secara statik mengendalikan penukaran tersebut. Mengetahui peraturan ini mungkin akan menjimatkan banyak masa ketika cuba mencari tahu mengapa kod tertentu disusun atau tidak.

Kod yang digunakan dalam artikel ini boleh didapati di GitHub.