Java Academy · Pelajaran

StringBuilder berbanding StringBuffer

Pertukaran keselamatan utas

Pelajaran 4 daripada 413 langkah

StringBuilder berbanding StringBuffer ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 4 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.

Dua Kelas yang Boleh Diubah

Java mempunyai dua kelas rentetan yang boleh diubah: StringBuilder dan StringBuffer. Antara muka pengaturcaraan mereka hampir serupa, tetapi kedua-duanya berbeza dalam satu perkara penting: keselamatan utas.

Antara Muka Pengaturcaraan yang Sama

Kedua-dua kelas menawarkan append, insert, delete, reverse dan kaedah lain. Kod yang menggunakan satu biasanya boleh ditukar kepada yang satu lagi dengan hanya mengubah nama jenis.

public class Main {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello").append(", ").append("World");
        System.out.println(sb);
    }
}

StringBuffer Disegerakkan

Kaedah StringBuffer adalah disegerakkan, bermakna berbilang utas boleh mengubah suai objek yang sama dengan selamat. Keselamatan ini mempunyai kos prestasi yang kecil.

public class Main {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("thread-safe");
        buffer.append("!");
        System.out.println(buffer);
    }
}

StringBuilder Tidak Disegerakkan

StringBuilder tidak menggunakan penyegerakan, menjadikannya lebih pantas. Komprominya ialah anda tidak boleh berkongsi satu objek merentas utas dengan selamat tanpa penyelarasan luaran.

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("fast");
        builder.append("!");
        System.out.println(builder);
    }
}

Bila Perlu Menggunakan StringBuilder

Gunakan StringBuilder dalam kes biasa: membina rentetan di dalam satu kaedah atau utas. Ini ialah pilihan lalai untuk hampir semua kod harian.

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

Bila Perlu Menggunakan StringBuffer

Pilih StringBuffer hanya apabila objek pembina yang sama benar-benar dikongsi dan diubah suai oleh berbilang utas. Situasi ini jarang berlaku dalam amalan.

public class Main {
    public static void main(String[] args) {
        StringBuffer shared = new StringBuffer("log: ");
        shared.append("event A; ");
        shared.append("event B");
        System.out.println(shared);
    }
}

Pemboleh Ubah Setempat Tidak Dikongsi

Pembina yang diisytiharkan dan digunakan hanya dalam satu kaedah tidak pernah kelihatan kepada utas lain, jadi StringBuilder sentiasa sesuai digunakan dalam situasi itu. Kekurangan penyegerakan tidak boleh menyebabkan masalah.

public class Main {
    static String build() {
        StringBuilder sb = new StringBuilder();
        sb.append("local only");
        return sb.toString();
    }
    public static void main(String[] args) {
        System.out.println(build());
    }
}

Perbezaan Prestasi

Overhed penyegerakan dalam StringBuffer menjadikannya lebih perlahan dalam penggunaan satu utas. Untuk gelung yang rapat, StringBuilder memberikan prestasi yang lebih baik.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append('x');
        }
        System.out.println("Built length: " + sb.length());
    }
}

Nota Sejarah

StringBuffer muncul dahulu, pada zaman awal Java. StringBuilder diperkenalkan dalam Java 5 sebagai alternatif yang lebih pantas dan tidak disegerakkan untuk kes penggunaan lazim yang melibatkan satu utas.

Membuat Pilihan yang Tepat

Tetapkan StringBuilder sebagai pilihan lalai. Tukar kepada StringBuffer hanya apabila anda boleh membuktikan bahawa satu instans dikongsi merentas utas. Jika tidak, anda menanggung kos keselamatan yang tidak diperlukan.

public class Main {
    public static void main(String[] args) {
        StringBuilder result = new StringBuilder();
        result.append("Use StringBuilder ").append("by default");
        System.out.println(result);
    }
}

Kedua-duanya Menukarkan kepada String

Kedua-dua kelas menghasilkan String tidak boleh ubah melalui toString(). Pilihan antara kedua-duanya hanya mempengaruhi proses pembinaan, bukan hasil akhirnya.

public class Main {
    public static void main(String[] args) {
        String a = new StringBuilder("one").toString();
        String b = new StringBuffer("two").toString();
        System.out.println(a + " " + b);
    }
}

Semakan Ringkas

Apakah perbezaan utama antara StringBuilder dengan StringBuffer?

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah mempelajari pertimbangannya:

Kedua-duanya mempunyai antara muka yang hampir sama
StringBuffer disegerakkan (selamat untuk utas, tetapi lebih perlahan)
StringBuilder tidak disegerakkan (lebih pantas)
Tetapkan StringBuilder sebagai pilihan lalai untuk pembinaan dalam satu utas
Gunakan StringBuffer hanya untuk instans yang benar-benar dikongsi

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 “StringBuilder berbanding StringBuffer” percuma?

Ya — teks penuh “StringBuilder berbanding StringBuffer” 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 “StringBuilder berbanding StringBuffer”?

Pertukaran keselamatan utas 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 4 daripada 4.

Berapa lamakah pelajaran “StringBuilder berbanding StringBuffer” 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