Berhati-hati dengan pemindahan jenis di Jawa

Java ialah bahasa yang ditaip kuat, tetapi masih boleh memindahkan nilai antara pembolehubah primitif pelbagai jenis. Sebagai contoh, saya boleh menetapkan nilai int kepada dua kali ganda tanpa sebarang masalah, selagi kapasiti storan jenis yang menerima nilai itu boleh mengendalikannya.

Lihat di bawah saiz setiap jenis primitif:

Memindahkan nilai kepada jenis dengan kapasiti storan yang lebih besar mempunyai nama teknikal: "penukaran meluas". Istilah dalam bahasa Portugis biasanya diterjemahkan sebagai "penukaran pembesaran" atau "penukaran meluas". Ia merujuk kepada proses di mana nilai daripada jenis data yang lebih kecil atau lebih terhad ditukar kepada jenis yang lebih besar atau lebih komprehensif tanpa kehilangan maklumat.

Tetapi bagaimana jika saya mahu memindahkan nilai kepada jenis dengan kapasiti storan yang lebih kecil? Pengkompil Java tidak menyukai ini, tetapi ia akan membenarkannya jika anda menghantarnya, seperti dalam contoh di bawah.

double decimal = 65.9;
int i = (int) decimal; //aqui ele perde a casa decimal e vira 65
char c = (char) i; //aqui ele vira a letra A (que corresponde a 65)

Jika saiz nilai yang akan pergi ke jenis baharu melebihi had jenis itu, sesuatu yang lebih dramatik boleh berlaku. Int i = 10 sesuai dengan pembolehubah bait, kerana ia mengandungi 8 bit dalam julat dari -128 hingga +127. Walau bagaimanapun, bagaimana jika saya ingin meletakkan int i = 128 dalam pembolehubah jenis bait... akan ada kehilangan maklumat.

public class Main
{
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;

        System.out.println(b); // o valor de b agora é -128 :S
    }
}

Autoboxing

Dalam catatan lepas [baca di sini], saya bercakap sedikit tentang kelas Wrapper. Sebagai contoh, saya telah menulis Integer.parse(i) = bayangkan bahawa i ialah sejenis
int primitif.

Pada masa ini, menggunakan kaedah parse Wrapper tidak lagi digalakkan kerana ia tidak digunakan lagi. Untuk mengubah primitif menjadi kelas Wrapper dan, dengan cara ini, gunakan kaedah terbina dalam, adalah disyorkan untuk melakukan "autoboxing", seperti dalam contoh:

Character ch = 'a';
Integer i = 10;

Perhatikan bahawa ia adalah pendekatan yang lebih langsung. Hanya tetapkan nilai sekaligus.

Untuk melakukan sebaliknya dan mengembalikan data sebagai jenis primitif, anda boleh melakukan "nyah kotak" menggunakan kaedah valueOf:

Integer i = 10;
int j = Integer.valueOf(i);

Membuat Wrapper daripada primitif, seperti yang saya katakan dalam catatan sebelum ini, mempunyai kelebihan untuk membolehkan anda menggunakan kaedah kelas dan menjadikan kehidupan lebih mudah apabila bekerja dengan data.

Versi pembalut primitif mungkin kelihatan sangat mirip pada pandangan pertama, tetapi JVM tidak memperlakukan objek dan primitif dengan cara yang sama, jangan lupa. Ingat bahawa primitif pergi ke Stack dan objek ke Heap [ingat di sini].

Dari segi prestasi, adalah jelas bahawa mendapatkan semula data daripada primitif adalah lebih murah untuk komputer, kerana nilainya disimpan secara langsung, dan bukan melalui rujukan. Jauh lebih cepat untuk mendapatkan sekeping data yang sudah siap daripada terus menyusun kepingan-kepingan itu dalam ingatan.

Tetapi terdapat kes di mana penggunaan Wrapper adalah penting. Sebagai contoh, apabila anda ingin bekerja dengan kelas ArrayList. Ia hanya menerima objek sebagai parameter, bukan nilai primitif.

Fleksibiliti yang dibawa oleh transformasi ini daripada primitif kepada objek dan sebaliknya adalah sangat menarik tentang bahasa. Tetapi kita perlu sedar tentang perangkap yang dibincangkan di sini dan banyak lagi.

Hanya untuk mengejutkan masyarakat (lol) Saya akan memberikan contoh kes bermasalah yang melibatkan tingkah laku kod yang tidak dijangka apabila bekerja dengan lebihan beban (saya belum membuat siaran tentang lebihan muatan lagi, tetapi saya akan melakukannya. Pada asasnya , lebihan beban berlaku apabila kaedah mempunyai tandatangan yang berbeza).

Kes ini disebut dalam buku "Effective Java", oleh Joshua Bloch.

public class SetListTest {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        List<Integer> list = new ArrayList<>();

        for (int i = -3; i < 3; i++) {
            set.add(i);
            list.add(i);
        }

        for (int i = 0; i < 3; i++) {
            set.remove(i);
            list.remove(i); // como corrigir: list.remove((Integer) i);
        }

        System.out.println(set + " " + list);

    }

Dalam program ini, objektifnya adalah untuk menambah nilai integer ​​daripada -3 kepada 2 [-3, -2, -1, 0, 1, 2] kepada set dan senarai. Kemudian padamkan nilai positif [0, 1 dan 2]. Tetapi, jika anda menjalankan kod ini, anda akan melihat bahawa set dan senarai itu tidak membentangkan hasil yang sama. Set mengembalikan [-3, -2, -1], seperti yang dijangkakan. Senarai kembali [-2, 0, 2].

Ini berlaku kerana panggilan kepada kaedah buang(i) terbina dalam kelas Senarai menganggap i sebagai int jenis primitif, dan tiada yang lain. Kaedah ini pula mengalih keluar elemen pada kedudukan i.

Panggilan kepada kaedah remove(i) kelas Set memanggil lebihan beban yang menerima objek Integer sebagai parameter, secara automatik menukar i, yang asalnya int, kepada Integer. Kelakuan kaedah ini, seterusnya, mengecualikan daripada elemen set yang mempunyai nilai sama dengan i (dan bukan indeks sama dengan i) - ambil perhatian bahawa jenis yang dijangkakan untuk kedua-dua set dan senarai adalah Integer. (Tetapkan set / Senarai senarai). Itulah sebabnya lebihan muatan yang dipilih untuk kaedah alih keluar, daripada kelas Set, menukarkannya kepada Integer.

Walaupun tingkah laku keluarkan dalam Senarai adalah untuk memadam mengikut indeks, alih keluar dalam Set adalah untuk memadam mengikut nilai. Semuanya disebabkan oleh lebihan penyingkiran yang menerima Integer.

Atas ialah kandungan terperinci Berhati-hati dengan pemindahan jenis di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!