Java Academy · Pelajaran

Membina rentetan dengan StringBuilder

Penggabungan yang cekap

Pelajaran 2 daripada 413 langkah

Membina rentetan dengan StringBuilder ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 2 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.

Pembina Rentetan yang Boleh Diubah

StringBuilder ialah jujukan aksara yang boleh diubah. Berbeza dengan String, anda boleh mengubah kandungannya di tempatnya, menjadikan pembinaan teks lebih cekap.

Mencipta StringBuilder

Cipta satu dengan new StringBuilder() untuk mendapatkan pembina kosong, atau berikan teks awal untuk memulakannya dengan kandungan.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        StringBuilder named = new StringBuilder("Hello");
        System.out.println("empty length: " + sb.length());
        System.out.println("named: " + named);
    }
}

Menambahkan Teks

Kaedah append menambahkan kandungan pada bahagian akhir. Kaedah ini menerima rentetan, nombor, aksara, nilai benar atau palsu dan banyak lagi.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Count: ");
        sb.append(5);
        sb.append(' ');
        sb.append(true);
        System.out.println(sb);
    }
}

Rantaian Kaedah

append mengembalikan pembina yang sama, jadi panggilan boleh dirangkaikan dengan lancar dalam satu ungkapan.

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

Membina dalam Gelung

Inilah kes penggunaan utama. Gunakan append di dalam gelung tanpa mencipta objek baharu setiap kali, kemudian tukarkannya sekali sahaja pada penghujungnya.

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

Menukar kepada String

Panggil toString() untuk mendapatkan String biasa yang tidak boleh diubah daripada pembina selepas anda selesai mengubahnya.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("result");
        String finalText = sb.toString();
        System.out.println(finalText.toUpperCase());
    }
}

Menggabungkan dengan Pemisah

Anda boleh membina senarai yang dipisahkan dengan koma dengan menambahkan pemisah antara item, sambil mengendalikan item terakhir dengan teliti.

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ann", "Ben", "Cara"};
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < names.length; i++) {
            sb.append(names[i]);
            if (i < names.length - 1) {
                sb.append(", ");
            }
        }
        System.out.println(sb);
    }
}

Membaca Panjang

length() memberitahu anda bilangan aksara yang sedang disimpan oleh pembina. Nilainya dikemas kini apabila anda menggunakan append.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("12345");
        System.out.println("Length: " + sb.length());
    }
}

Mengakses Aksara

Gunakan charAt(index) untuk membaca satu aksara mengikut kedudukan, sama seperti pada String.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Coddy");
        System.out.println("First: " + sb.charAt(0));
        System.out.println("Last: " + sb.charAt(sb.length() - 1));
    }
}

capacity Berbanding Panjang

Pembina menyimpan penimbal dalaman, iaitu capacity, yang berkembang secara automatik. Anda boleh memberikan capacity awal untuk mengurangkan perubahan saiz apabila anda mengetahui saiz akhir.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(100);
        sb.append("short");
        System.out.println("Length: " + sb.length());
        System.out.println("Capacity at least: " + (sb.capacity() >= 100));
    }
}

Pembina Praktikal

Dengan menggabungkan semuanya, bina rentetan laporan kecil dengan cekap menggunakan panggilan append yang dirangkaikan dan gelung.

public class Main {
    public static void main(String[] args) {
        int[] sales = {100, 250, 75};
        StringBuilder report = new StringBuilder("Sales Report\n");
        int total = 0;
        for (int i = 0; i < sales.length; i++) {
            report.append("Day ").append(i + 1).append(": ").append(sales[i]).append('\n');
            total += sales[i];
        }
        report.append("Total: ").append(total);
        System.out.println(report);
    }
}

Semakan Pantas

Mengapakah StringBuilder lebih cekap daripada penggabungan berulang dengan + dalam gelung?

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari cara membina rentetan dengan StringBuilder:

Ia ialah jujukan aksara yang boleh diubah
append menambahkan kandungan dan menyokong perangkaian
Sesuai untuk membina teks dalam gelung
Panggil toString() untuk mendapatkan String akhir
capacity awal mengelakkan perubahan saiz

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 “Membina rentetan dengan StringBuilder” percuma?

Ya — teks penuh “Membina rentetan dengan StringBuilder” 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 “Membina rentetan dengan StringBuilder”?

Penggabungan yang cekap 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 2 daripada 4.

Berapa lamakah pelajaran “Membina rentetan dengan StringBuilder” 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