Pengenalan String, StringBuffer dan StringBuilder di Java

Ada tiga kelas di Java untuk bekerja dengan data teks: String , StringBuffer dan StringBuilder . Setiap pengembang pertama kali menemukan hal ini di awal pembelajaran bahasa. Bagaimana dengan dua sisanya? Apa perbedaannya, dan kapan waktu terbaik untuk menggunakan kelas tertentu? Secara umum, perbedaan di antara keduanya kecil, tetapi lebih baik memahami semuanya dalam praktik :)

• Kelas string di Java
• Kelas StringBuffer di Java
• Kelas StringBuilder di Java

Kelas tali

Kelas ini mewakili serangkaian karakter. Semua literal string yang didefinisikan dalam program, seperti "Ini adalah String" adalah turunan dari kelas String. String memiliki dua fitur mendasar:

• ini adalah kelas yang tidak dapat diubah
• ini kelas terakhir

Secara umum, kelas String tidak dapat memiliki turunan ( final) dan instance kelas tidak dapat diubah setelah pembuatan ( immutable). Hal ini memberi kelas String beberapa keuntungan penting:

1. Karena kekekalan, kode hash dari sebuah instance kelas String di-cache. Tidak perlu dievaluasi setiap saat karena nilai field objek tidak akan pernah berubah setelah dibuat. Ini memberikan kinerja tinggi ketika menggunakan kelas ini sebagai kunci untuk HashMap.

2. Kelas String dapat digunakan dalam lingkungan multi-thread tanpa sinkronisasi tambahan.

3. Fitur lain dari kelas String adalah ia membebani +operator " " di Java. Oleh karena itu, penggabungan (penambahan) string cukup sederhana:

public static void main(String[] args) {
    String command = "Follow" + " " + "the" + " " + "white" + " " + "rabbit";
    System.out.println(command); // Follow the white rabbit
}

Di bawah tenda, penggabungan string dilakukan oleh kelas StringBuilder atau StringBuffer (sesuai kebijaksanaan kompiler) dan sebuah metode append(kita akan membicarakan kelas-kelas ini nanti). Jika kita menambahkan instance kelas String dengan instance kelas lain, maka instance kelas lain akan direduksi menjadi representasi string:

public static void main(String[] args) {       
    Boolean b = Boolean.TRUE;
    String result = "b is " + b;    
    System.out.println(result); //b is true
}

Ini adalah properti lain yang menarik dari kelas String: objek dari kelas mana pun dapat dilemparkan ke representasi string menggunakan metode toString()yang ditentukan dalam kelas Objectdan diwarisi oleh semua kelas lainnya. Seringkali metode toString() pada suatu objek dipanggil secara implisit. Misalnya, ketika kita menampilkan sesuatu di layar atau menambahkan String ke objek kelas lain. Kelas String memiliki satu fitur lagi. Semua literal string yang didefinisikan dalam kode Java, seperti "asdf", di-cache pada waktu kompilasi dan ditambahkan ke kumpulan string yang disebut. Jika kita menjalankan kode berikut:

String a = "Wake up, Neo";
String b = "Wake up, Neo";

System.out.println(a == b);

Kita akan melihat nilai true di konsol karena variabel asebenarnya akan bmerujuk ke instance kelas String yang sama yang ditambahkan ke kumpulan string pada waktu kompilasi. Artinya, instance kelas yang berbeda dengan nilai yang sama tidak dibuat, dan memori disimpan.

Kekurangan:

Tidak sulit untuk menebak bahwa kelas String diperlukan terutama untuk bekerja dengan string. Namun dalam beberapa kasus, fitur kelas String di atas dapat berubah dari kelebihan menjadi kekurangan. Setelah string dibuat dalam kode Java, banyak operasi yang sering dilakukan pada string tersebut:

• mengkonversi string ke register yang berbeda;
• ekstraksi substring;
• rangkaian;
• dll.

Mari kita lihat kode ini:

public static void main(String[] args) {

    String s = " Wake up, Neo! ";
    s = s.toUpperCase();
    s = s.trim();

    System.out.println("\"" + s + "\"");
}

Sekilas, sepertinya kita baru saja menerjemahkan kalimat “Bangun, Neo!” menjadi huruf besar, hapus spasi ekstra dari string ini dan bungkus dengan tanda kutip. Faktanya, karena kelas String tidak dapat diubah, sebagai hasil dari setiap operasi, instance string baru dibuat dan instance string lama dibuang, sehingga menghasilkan sampah dalam jumlah besar. Bagaimana cara menghindari pemborosan memori?

kelas StringBuffer

Untuk menangani terciptanya sampah sementara akibat modifikasi pada objek String, Anda dapat menggunakan kelas StringBuffer. Ini adalah mutablekelas, mis. dapat diubah. Objek kelas StringBuffer dapat berisi sekumpulan karakter tertentu, yang panjang dan nilainya dapat diubah dengan memanggil metode tertentu. Mari kita lihat bagaimana kelas ini bekerja. Untuk membuat objek baru, gunakan salah satu konstruktornya, misalnya:

• StringBuffer() - akan membuat objek kosong (tanpa karakter).
• StringBuffer(String str) - akan membuat objek berdasarkan variabel str (berisi semua karakter str dalam urutan yang sama)

Praktik:

StringBuffer sb = new StringBuffer();
StringBuffer sb2 = new StringBuffer("Not empty");

Penggabungan string melalui StringBuffer di Java dilakukan menggunakan file append. Secara umum, metode appenddi kelas StringBuffer dibebani sedemikian rupa sehingga dapat menerima hampir semua tipe data:

public static void main(String[] args) {
    StringBuffer sb = new StringBuffer();

    sb.append(new Integer(2));
    sb.append("; ");
    sb.append(false);
    sb.append("; ");
    sb.append(Arrays.asList(1,2,3));
    sb.append("; ");

    System.out.println(sb); // 2; false; [1, 2, 3]; 
}

Metode appendmengembalikan objek yang dipanggil (seperti banyak metode lainnya), yang memungkinkannya dipanggil dalam “rantai”. Contoh di atas dapat ditulis seperti ini:

public static void main(String[] args) {
    StringBuffer sb = new StringBuffer();

    sb.append(new Integer(2))
            .append("; ")
            .append(false)
            .append("; ")
            .append(Arrays.asList(1,2,3))
            .append("; ");

    System.out.println(sb); // 2; false; [1, 2, 3];
}

Kelas StringBuffer memiliki sejumlah metode untuk bekerja dengan string. Mari kita daftar yang utama:

• delete(int start, int end)— menghapus substring karakter mulai dari posisi start, berakhirend
• deleteCharAt(int index)— menghapus karakter pada posisinyaindex
• insert(int offset, String str)— menyisipkan garis strpada posisi offset. Metode ini insertjuga kelebihan beban dan dapat mengambil argumen berbeda
• replace(int start, int end, String str)- akan mengganti semua karakter dari satu posisi startke posisi endlainnyastr
• reverse()— membalikkan urutan semua karakter
substring(int start)- akan mengembalikan substring yang dimulai dari posisi start
• substring(int start, int end)- akan mengembalikan substring mulai dari posisi startke posisiend

Daftar lengkap metode dan konstruktor ada di dokumentasi resmi . Bagaimana cara kerja metode di atas? Mari kita lihat dalam praktiknya:

public static void main(String[] args) {
     String numbers = "0123456789";

     StringBuffer sb = new StringBuffer(numbers);

     System.out.println(sb.substring(3)); // 3456789
     System.out.println(sb.substring(4, 8)); // 4567
     System.out.println(sb.replace(3, 5, "ABCDE")); // 012ABCDE56789

     sb = new StringBuffer(numbers);
     System.out.println(sb.reverse()); // 9876543210
     sb.reverse(); // Return the original order

     sb = new StringBuffer(numbers);
     System.out.println(sb.delete(5, 9)); // 012349
     System.out.println(sb.deleteCharAt(1)); // 02349
     System.out.println(sb.insert(1, "One")); // 0One2349
    }

Keuntungan:

1. Seperti telah disebutkan, StringBuffer adalah kelas yang bisa berubah, jadi bekerja dengannya tidak menghasilkan jumlah sampah memori yang sama seperti dengan String. Oleh karena itu, jika banyak modifikasi yang dilakukan pada string, lebih baik menggunakan StringBuffer.

2. StringBuffer adalah kelas aman thread. Metodenya disinkronkan dan instance dapat digunakan oleh banyak thread secara bersamaan.

Kekurangan:

Di satu sisi, keamanan benang merupakan keunggulan kelasnya, dan di sisi lain, merupakan kerugian. Metode yang disinkronkan lebih lambat dibandingkan metode yang tidak disinkronkan. Di sinilah StringBuilder berperan. Mari kita cari tahu apa itu kelas Java - StringBuilder, metode apa yang dimilikinya dan apa saja fitur-fiturnya.

kelas StringBuilder

StringBuilder di Java adalah kelas yang mewakili urutan karakter. Ini sangat mirip dengan StringBuffer dalam segala hal kecuali keamanan thread. StringBuilder menyediakan API yang mirip dengan StringBuffer. Mari kita tunjukkan ini menggunakan contoh yang sudah familiar, mengganti deklarasi variabel dari StringBufer ke StringBuilder:

public static void main(String[] args) {
    String numbers = "0123456789";

    StringBuilder sb = new StringBuilder(numbers);

    System.out.println(sb.substring(3)); //3456789
    System.out.println(sb.substring(4, 8)); //4567
    System.out.println(sb.replace(3, 5, "ABCDE")); //012ABCDE56789

    sb = new StringBuilder(numbers);
    System.out.println(sb.reverse()); //9876543210
    sb.reverse(); // Return the original order

    sb = new StringBuilder(numbers);
    System.out.println(sb.delete(5, 9)); //012349
    System.out.println(sb.deleteCharAt(1)); //02349
    System.out.println(sb.insert(1, "One")); //0One2349
}

Satu-satunya perbedaan adalah StringBuffer aman untuk thread dan semua metodenya disinkronkan, sedangkan StringBuilder tidak. Ini adalah satu-satunya fitur. StringBuilder di Java lebih cepat daripada StringBuffer karena metode yang tidak sinkron. Oleh karena itu, dalam banyak kasus, kecuali dalam lingkungan multi-thread, lebih baik menggunakan StringBuilder untuk program Java. Kami merangkum semuanya dalam tabel perbandingan ketiga kelas:

String vs StringBuffer vs StringBuilder

Anda dapat mempelajari topik ini lebih detail di level kedua dari pencarian Java Multithreading di kursus JavaRush:

• String internal, metode substring
• StringBuilder, StringBuffer
• Tugas untuk StringBuilder, StringBuffer