Java Academy · Pelajaran

Mengapa rentetan tidak boleh berubah

Fahami ketidakbolehubahan rentetan

Pelajaran 1 daripada 413 langkah

Mengapa rentetan tidak boleh berubah ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Rentetan Tidak Boleh Berubah

Dalam Java, String adalah tidak boleh diubah: setelah dicipta, aksaranya tidak boleh berubah. Sebarang kaedah yang kelihatan seperti mengubah rentetan sebenarnya mengembalikan rentetan baharu.

Kaedah Mengembalikan Rentetan Baharu

toUpperCase(), replace() dan kaedah lain tidak mengubah yang asal. Kaedah tersebut menghasilkan String baharu dan membiarkan yang asal tanpa perubahan.

public class Main {
    public static void main(String[] args) {
        String original = "hello";
        String upper = original.toUpperCase();
        System.out.println("original: " + original);
        System.out.println("upper: " + upper);
    }
}

Penetapan Semula Bukan Perubahan

Apabila anda menulis s = s + "!", pemboleh ubah itu kini merujuk kepada rentetan baharu. Objek rentetan lama tidak berubah dan mungkin dikutip oleh pengutip sampah.

public class Main {
    public static void main(String[] args) {
        String s = "hi";
        String firstRef = s;
        s = s + "!";
        System.out.println("s: " + s);
        System.out.println("firstRef: " + firstRef);
    }
}

Mengapa Tidak Boleh Berubah?

Sifat tidak boleh berubah memberikan manfaat sebenar:

Keselamatan utas: rentetan boleh dikongsi tanpa kunci
Penyimpanan sementara: kod cincang dan entri kumpulan kekal sah
Keselamatan: rentetan yang dihantar kepada kaedah tidak boleh diubah tanpa pengetahuan anda

Kumpulan Rentetan

Literal rentetan yang sama boleh berkongsi satu objek dalam kumpulan rentetan. Hal ini selamat hanya kerana rentetan tidak pernah berubah. Di sini, dua literal merujuk kepada objek yang sama dalam kumpulan.

public class Main {
    public static void main(String[] args) {
        String a = "java";
        String b = "java";
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}

Penggunaan String Baharu Memecahkan Pengumpulan

Penggunaan new String(...) memaksa penciptaan objek berasingan, jadi kesamaan rujukan berbeza walaupun kandungannya sama. Sentiasa bandingkan kandungan dengan equals.

public class Main {
    public static void main(String[] args) {
        String a = "java";
        String b = new String("java");
        System.out.println("== : " + (a == b));
        System.out.println("equals: " + a.equals(b));
    }
}

Kos Penggabungan

Setiap + pada rentetan mencipta objek baharu. Melakukannya dalam gelung memperuntukkan banyak rentetan berumur pendek, lalu membazirkan masa dan memori.

public class Main {
    public static void main(String[] args) {
        String result = "";
        for (int i = 1; i <= 5; i++) {
            result = result + i;
        }
        System.out.println(result);
    }
}

Pertumbuhan Kuadratik

Oleh sebab setiap penggabungan menyalin semua aksara sebelumnya, pembinaan rentetan panjang dengan + dalam gelung berkembang dengan buruk, kira-kira O(n kuasa dua). Inilah masalah prestasi utamanya.

public class Main {
    public static void main(String[] args) {
        String s = "";
        for (int i = 0; i < 1000; i++) {
            s += "x";
        }
        System.out.println("Length: " + s.length());
    }
}

Nilai Tidak Boleh Berubah Boleh Diramal

Menghantar rentetan kepada kaedah adalah selamat: kaedah itu tidak boleh mengubah salinan anda. Di sini, kaedah tersebut membina rentetan baharu dan nilai pemanggil kekal utuh.

public class Main {
    static void shout(String s) {
        s = s + "!!!";
        System.out.println("inside: " + s);
    }
    public static void main(String[] args) {
        String msg = "hello";
        shout(msg);
        System.out.println("outside: " + msg);
    }
}

Pratonton Penyelesaian

Apabila anda perlu membina rentetan dengan cekap, Java menyediakan StringBuilder, iaitu kelas pendamping yang boleh diubah. Kelas ini mengubah kandungan di tempatnya dan bukannya memperuntukkan objek baharu setiap kali.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i);
        }
        System.out.println(sb.toString());
    }
}

Membandingkan Dua Pendekatan

Untuk beberapa penggabungan, + sangat sesuai dan mudah dibaca. Untuk banyak penggabungan dalam gelung, utamakan StringBuilder. Buat pilihan berdasarkan jumlah pembinaan yang anda lakukan.

public class Main {
    public static void main(String[] args) {
        String simple = "a" + "b" + "c";
        StringBuilder sb = new StringBuilder("a");
        sb.append("b").append("c");
        System.out.println(simple);
        System.out.println(sb);
    }
}

Semakan Pantas

Apakah yang sebenarnya berlaku apabila anda memanggil s.toUpperCase() pada String?

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari sebab rentetan tidak boleh berubah:

Kandungan String tidak pernah berubah
Kaedah mengembalikan rentetan baharu
Sifat tidak boleh berubah membolehkan keselamatan utas, pengumpulan dan keselamatan
Penggabungan dengan + dalam gelung berkembang dengan buruk
StringBuilder ialah penyelesaian yang boleh diubah

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 104
Pelajaran: 374

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengapa rentetan tidak boleh berubah” percuma?

Ya — teks penuh “Mengapa rentetan tidak boleh berubah” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengapa rentetan tidak boleh berubah”?

Fahami ketidakbolehubahan rentetan Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Mengapa rentetan tidak boleh berubah” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy