Autoboxing dan Unboxing di Java

Autoboxing ialah penukaran automatik pengkompil Java antara jenis primitif dan objek kelas pembalut yang sepadan, iaitu, penukaran daripada int kepada Integer, dua kali ganda kepada Double, dll. Unboxing ialah penukaran automatik daripada objek kelas pembalut kepada primitif yang setara, iaitu, Integer kepada int. Ciri ini diperkenalkan dalam versi 1.5 Java.

Bagaimanakah Autoboxing dan Unboxing berfungsi di Java?

Pengkompil menggunakan kaedah valueOf() untuk menukar primitif kepada objek pembalut yang sepadan (iaitu autoboxing) secara dalaman, dan dalam kes sebaliknya, ia menggunakan intValue(), doubleValue(), dsb., seperti paradigma untuk menyahkotak.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Pemetaan kelas jenis dan pembalut primitif dalam java adalah seperti berikut:

Contoh

Mari ambil ArrayList of Integers dan gunakan konsep unboxing.

import java.util.ArrayList;
public class MyClass {
public static void main(String args[]) <em>{</em>
ArrayList<Integer> intlist = new ArrayList<Integer>();
//wrapper Integer objects being added here
intlist.add(1);
interest.add(2);
//auto-unboxing is happening here
int x = intlist.get(0);
System.out.println(x);
}
}

Oleh itu, dalam contoh di atas, semasa menambah nilai kepada x, kita melihat bahawa x nampaknya primitif. Akibatnya, nyahkotak berlaku di sini secara automatik semasa tugasan selesai.

public class MyClass {
public static void main(String args[]) {
Integer sum =0;
for(int i=0;i<10;i++)
{
sum = sum + i;
}
System.out.println(sum);
}
}

• Di atas, kami telah menunjukkan contoh kedua dalam konteks ini, di mana senario biasa telah dibentangkan. Jika anda mengetahui penciptaan objek dalam Java, anda boleh melihat bahawa "Jumlah integer =0" mengisytiharkan objek, dan apabila kita melakukan pengiraan di dalam untuk gelung, maka kita dapat melihat bahawa nilai primitif "i" sedang ditambah pada pembungkus "jumlah".
• Oleh itu, seseorang boleh mendapati bahawa pertama sekali, penukaran daripada pembalut kepada primitif akan berlaku, kerana pengendali "+" berfungsi pada primitif sahaja; oleh itu, penyahkotak objek akan berlaku dahulu. Kemudian, pengiraan akan berlaku, dan selepas itu, autoboxing objek akan berlaku semula. Kemudian, nilai akan diberikan kepada pembolehubah "jumlah".
• Ini memberikan overhed yang tidak perlu pada JVM kerana banyak objek Integer perantaraan akan dicipta dan kemudian dimusnahkan (untuk menjadi sampah kemudiannya), dengan itu menyebabkan kelembapan. Akibatnya, logik sedemikian hendaklah dikendalikan dengan berhati-hati.
• Mari kita lihat bagaimana keadaan berbeza daripada persepsi umum. Untuk memahami autoboxing dan unboxing, kami akan menggunakan beberapa pengekodan.

Pertimbangkan coretan yang diletakkan di bawah; apakah hasil daripada ini?

public class Main
{
public static void main(String[] args) {
Integer m = 34123;
Integer x = 34123;
System.out.println(x==m);
}
}

• Jika anda menyebut "benar",  maka anda "salah", kerana outputnya juga "salah". Memandangkan kita boleh membandingkan julat integer dari -128 hingga 127, nilai yang berada di luar julat ini perlu dinyahkotak.
• Akibatnya, kita mesti membandingkan intValue() daripada integer di atas. Buat masa ini, pengkompil melakukan ini menggunakan harta valueOf().
• Mungkin, jika ini termasuk dalam julat yang disebut di atas, maka kod di atas akan memberikan "benar"— kerana ia akan merujuk kepada kumpulan literal integer untuk perbandingan.

public class Main
{
public static void main(String[] args) {
Integer m = 100;
Integer x = 100;
System.out.println(x==m);
}
}

Ini akan dinilai kepada nilai "benar", kerana 100 terdapat dalam kumpulan literal.

Autoboxing dan Unboxing dalam Java dengan Kaedah Overloading

• Sebelum kami menandai autoboxing dan unboxing dengan kaedah terlebih muatan, kami menganggap bahawa pembaca memahami konsep kaedah lebih muatan. Kami hanya akan memberikan sedikit cerapan dan untuk mendapatkan maklumat lanjut, sila rujuk dokumentasi Oracle mengenai perkara yang sama.
• Pembebanan kaedah ialah proses mempersembahkan berbilang varian bagi mana-mana kaedah pengiraan dengan menggunakan nama kaedah yang sama dengan bilangan argumen input yang berbeza, jenis data pembolehubah yang berbeza dengan nama yang sama dan sebagainya.
• Mari kita ambil contoh untuk memahaminya dengan lebih baik. Imej output dipaparkan di bawah.

public class Main
{
public static void main(String[] args) {
Overload obj =  new Overload();
int i =5;
obj.printval(5);
Integer m = i;
obj.printval(m);
}
}
class Overload
{
public void printval(int i)
{
System.out.println("printing the unboxed value "+ i);
}
public void printval(Integer i)
{
System.out.println("printing the autoboxed value "+ i);
}
}

Output:

• Akibatnya, tingkah laku di atas menunjukkan dengan jelas bahawa teknik autoboxing berguna untuk konsep lebih muatan dan harus digunakan dengan berhati-hati semasa mengekod.

Kelebihan Autoboxing dan Unboxing di Java

• Pengkompil secara automatik melakukan penukaran yang sesuai.
• Pembangun menulis lebih sedikit kod, dengan itu mencipta kod yang lebih bersih.
• Tidak memerlukan ungkapan penghantaran jenis manual.

 Kesimpulan

Kami melihat kes penggunaan autoboxing dan unboxing dan betapa tersiratnya konsep ini, bersama dengan kebaikan dan keburukannya. Ia mesti digunakan dengan berhati-hati apabila mengekod; jika tidak, ia boleh menambah overhed penukaran pengiraan yang tidak perlu. Akibatnya, penukaran mesti dilakukan secara primitif untuk mengelakkan overhed pengumpulan sampah berlebihan dan penciptaan objek sementara. Kami juga melihat kes penggunaan autoboxing dengan konsep lebihan di Jawa. Anda boleh menyemak beberapa lagi kekangan bersama ini.

Atas ialah kandungan terperinci Autoboxing dan Unboxing di Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!