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
final
) dan instance kelas tidak dapat diubah setelah pembuatan ( immutable
). Hal ini memberi kelas String beberapa keuntungan penting:
-
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
. -
Kelas String dapat digunakan dalam lingkungan multi-thread tanpa sinkronisasi tambahan.
-
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 Object
dan 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 a
sebenarnya akan b
merujuk 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.
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 adalahmutable
kelas, 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)
StringBuffer sb = new StringBuffer();
StringBuffer sb2 = new StringBuffer("Not empty");
Penggabungan string melalui StringBuffer di Java dilakukan menggunakan file append
. Secara umum, metode append
di 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 append
mengembalikan 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 posisistart
, berakhirend
deleteCharAt(int index)
— menghapus karakter pada posisinyaindex
insert(int offset, String str)
— menyisipkan garisstr
pada posisioffset
. Metode iniinsert
juga kelebihan beban dan dapat mengambil argumen berbedareplace(int start, int end, String str)
- akan mengganti semua karakter dari satu posisistart
ke posisiend
lainnyastr
reverse()
— membalikkan urutan semua karaktersubstring(int start, int end)
- akan mengembalikan substring mulai dari posisistart
ke posisiend
substring(int start)
- akan mengembalikan substring yang dimulai dari posisi
start
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:
-
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
. -
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
Rangkaian | StringBuffer | Pembuat String | |
---|---|---|---|
Kemampuan untuk berubah | Immutable (TIDAK) |
mutable (Ya) |
mutable (Ya) |
Kemungkinan diperpanjang | final (TIDAK) |
final (TIDAK) |
final (TIDAK) |
Keamanan benang | Ya, karena kekekalan | Ya, karena sinkronisasi | TIDAK |
Kapan harus digunakan | Saat bekerja dengan string yang jarang dimodifikasi | Saat bekerja dengan string yang akan sering dimodifikasi di lingkungan multi-thread | Saat bekerja dengan string yang akan sering dimodifikasi dalam lingkungan thread tunggal |
GO TO FULL VERSION