StringJoiner Java Beserta Contohnya

Class StringJoiner Java merupakan class yang menjadi bagian dari package java.util yang digunakan untuk mengonstruksi sebuah ukuran karakter bertipe string yang dipisahkan oleh delimiter dengan tambahan prefix pada bagian awal dan bagian akhir diberikan suffix. Proses ini juga bisa diselesaikan dengan bantuan class StringBuilder setelah ditambahkan delimeter pada setiap string, sedangkan StringJoiner menyediakan cara yang lebih mudah tanpa terlalu banyak membuat kode program.

Sebelum lebih lanjut mempelajari materi tentang StringJoiner Java Beserta Contohnya, terlebih dahulu pelajari materi tentang: Perbedaan Antara print() dan println() Java, Format Output Java Beserta Contohnya, dan Input Output Java pada Competitive Programming.

Dalam pemrograman Java, terkadang pengembang perlu menggabungkan beberapa string menjadi satu. Salah satu pendekatan yang umum digunakan adalah dengan menggunakan operator + atau metode concat(). Namun, ketika memiliki sejumlah besar string yang perlu digabungkan, pendekatan ini bisa menjadi kurang efisien karena setiap kali menggunakan operator + atau metode concat(), JVM (Java Virtual Machine) akan membuat objek string baru.

Untuk mengatasi masalah ini, Java menyediakan kelas StringJoiner yang memungkinkan untuk menggabungkan string secara efisien dengan meminimalkan jumlah objek yang dibuat dalam prosesnya.

Mengenal StringJoiner

StringJoiner adalah kelas yang ada dalam paket java.util sejak Java 8. Ini memungkinkan untuk menggabungkan sejumlah string dengan delimiter tertentu (opsional), dan juga dapat menambahkan awalan dan akhiran opsional pada hasil gabungan.

Konstruktur Class StringJoiner

StringJoiner(CharSequence delimiter): Berfungsi untuk mengonstruktsi sebuah StringJoiner tanpa menggunakan karakter, tanpa menggunakan prefix, ataupun suffix, dan duplikasi dari penyedia delimeter.

Sintak: public StringJoiner(CharSequence delimiter)

Parameter: Urutan dari karakter akan digunakan diantara setiap elemen yang ditambahkan ke nilai StringJoiner.

Exception Thrown: Diberikan NullPointerException jika delimeter bernilai null.

StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix): Berfungsi untuk mengonstruksi sebuah StringJoiner tanpa menggunakan karakter duplikasi dari penyedia prefix, delimiter, dan suffix. Jika tidak ada karakter yang ditambahkan kebagian StringJoiner dan method mengakses nilai string dipanggil, maka hal tersebut akan mengakibatkan pemanggilan nilai return prefix + suffix (atau properti thereof) pada bagian hasil kecuali setEmptyValue telah dipanggil terlebih dahulu.

Sintak: public StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

Parameter:

• Urutan karakter yang digunakan diantara setiap elemen yang ditambahkan ke nilai StringJoiner.
• Urutan karakter yang digunakan pada bagian awal.
• Ukuran karakter dari karakter yang digunakan pada bagian akhir.

Exception Thrown: Diberikan NullPointerException jika prefix, delimiter, atau suffix bernilai null.

Method Class StringJoiner

Performa tindakan dari class aksi StringJoiner adalah sebagai berikut:

• add(): Berfungsi untuk menambahkan duplikasi dari setiap nilai CharSequence yang diberikan sebagai elemen selanjutnya dari nilai StringJoiner. Jika newElement bernilai null, maka keterangan "null" akan ditambahkan.
• length(): Berfungsi untuk mengembalikan nilai length dari representasi string pada StringJoiner.
• merge(): Berfungsi untuk menambah konten dari StringJoiner yang diberikan tanpa menggunakan prefix dan suffix sebagai elemen selanjutnya jika nilainya tidak kosong. Jika nilai StringJoiner adalah kosong, maka proses pemanggilan tidak memberikan efek apapun. Misalkan StringJoiner lain menggunakan pembatas yang berbeda. Dalam hal ini, elemen dari StringJoiner lainnya digabungkan dengan pembatas tersebut, dan hasilnya ditambahkan ke StringJoiner ini sebagai elemen tunggal.
• toString(): Berfungsi untuk mengembalikan nilai object string dari StringJoiner.
• setEmptyValue(): Berfungsi untuk mengatur nilai string yang akan digunakan ketika menentukan nilai representasi string dari StringJoiner, dan tidak menambahkan elemen apapun yang telah ditambahkan sebelumnya, begitupula jika nilainya adalah kosong.

Contoh:

// Program Java untuk

// mendemonstrasikan method

// class StringJoiner class.

// Mengimpor class yang

// dibutuhkan.

import java.util.ArrayList;

import java.util.StringJoiner;

// Main class

public class MKN {

// Method main driver

public static void main(String[] args)

{

// Membuat Arralylist kosond

// dari tipe string.

ArrayList<String> al = new ArrayList<>();

// Menambah elemen dari daftar

// sebelumnya.

al.add("Ram");

al.add("Shyam");

al.add("Alice");

al.add("Bob");

// Menciptakan object class

// di dalam fungsi main().

StringJoiner sj1 = new StringJoiner(",");

// Penggunaan method

// setEmptyValue().

sj1.setEmptyValue("sj1 is empty");

System.out.println(sj1);

// Penggunaan method add()

sj1.add(al.get(0)).add(al.get(1));

System.out.println(sj1);

// Penggunaan method length().

System.out.println("Length of sj1 : "

+ sj1.length());

StringJoiner sj2 = new StringJoiner(":");

sj2.add(al.get(2)).add(al.get(3));

// Penggunaan method merge().

sj1.merge(sj2);

// Penggunaan method

// toString().

System.out.println(sj1.toString());

System.out.println("Length of new sj1 : "

+ sj1.length());

}

}

Output:

sj1 is empty
Ram,Shyam
Length of sj1 : 9
Ram,Shyam,Alice:Bob
Length of new sj1 : 19

Baca Juga:

• StringBuffer Java Beserta Penjelasannya
• StringBuilder Java Beserta Penjelasannya
• Object String Java Bersifat Kekal
• String vs StringBuilder vs StringBuffer Java dan Penjelasannya

Keuntungan penggunaan StringJoiner:

• Efisiensi Memori: Dibandingkan dengan pendekatan tradisional menggunakan operator + atau metode concat(), StringJoiner menghasilkan lebih sedikit objek string di dalam heap, karena string yang dihasilkan hanya satu objek.
• Fleksibilitas: Pengembang dapat dengan mudah mengontrol delimiter, awalan, dan akhiran pada string yang dihasilkan.
• Thread Safety: StringJoiner tidak menyediakan operasi mutable (yang mengubah state) dan karenanya aman untuk digunakan dalam thread yang berbeda.
• Mudah Digunakan dalam Loop: Saat pengembang memiliki kumpulan data yang perlu digabungkan, pengembang dapat dengan mudah menggunakan StringJoiner dalam loop untuk menambahkan setiap elemen ke dalam string gabungan. Ini memberikan pendekatan yang bersih dan efisien untuk operasi semacam itu.
• Penanganan Nilai Null: StringJoiner memiliki metode setEmptyValue(String) yang memungkinkan menentukan nilai default yang akan dikembalikan jika tidak ada elemen yang ditambahkan ke dalamnya. Ini berguna jika ingin menghindari string kosong sebagai hasilnya.
• Penggabungan Objek Selain String: Meskipun namanya adalah StringJoiner, kelas ini tidak terbatas pada penggabungan string saja. Pengembang dapat menggunakan StringJoiner untuk menggabungkan objek apa pun dengan mengonversinya menjadi string terlebih dahulu menggunakan metode toString().
• Kompatibilitas dengan Stream API: Dengan Java 8 dan yang lebih baru, pengembang dapat menggabungkan StringJoiner dengan Stream API untuk melakukan operasi seperti filtering, mapping, atau sorting pada data sebelum menggabungkannya. Ini memungkinkan untuk melakukan operasi yang lebih kompleks dengan cara yang bersih dan terbaca.

Meskipun StringJoiner memiliki banyak keuntungan, ada beberapa pertimbangan yang perlu diperhatikan:

• Tidak Cocok untuk Penggunaan Kasus yang Sederhana: Untuk kasus sederhana dimana pengembang hanya perlu menggabungkan beberapa string dengan delimiter sederhana, menggunakan StringJoiner mungkin terlalu berlebihan. Pendekatan tradisional dengan menggunakan operator + atau metode concat() mungkin lebih mudah dan lebih langsung untuk digunakan.
• Pembatasan Pada Penanganan Delimiter dan Prefix/Suffix: StringJoiner memiliki batasan pada delimiter, awalan, dan akhiran yang dapat digunakan. Misalnya, jika delimiter, awalan, atau akhiran yang pengembang inginkan adalah string yang lebih kompleks atau panjang, mungkin lebih sulit untuk menanganinya dengan StringJoiner.
• Kinerja yang Tidak Optimal untuk Jumlah String yang Sangat Besar: Meskipun StringJoiner lebih efisien daripada penggunaan operator + dalam hal kinerja dan penggunaan memori, untuk jumlah string yang sangat besar, kinerjanya mungkin masih tidak optimal. Dalam kasus seperti itu, mungkin perlu dipertimbangkan pendekatan lain yang lebih efisien.
• Tidak Mendukung Format String: Jika pengembang perlu melakukan format pada setiap elemen sebelum digabungkan, StringJoiner tidak menyediakan cara langsung untuk melakukan ini. Pengembang harus melakukan format secara terpisah sebelum menambahkannya ke StringJoiner.
• Tidak Mendukung Operasi Immutable: StringJoiner adalah kelas mutable, yang berarti pengembang dapat mengubahnya setelah dibuat dengan menambahkan atau menghapus elemen. Ini mungkin menjadi masalah dalam beberapa kasus dimana pengembang memerlukan operasi yang immutable (tidak dapat diubah), terutama dalam lingkungan yang memerlukan keamanan thread.
• Tidak Cocok untuk Penggabungan Besar dengan Pola yang Rumit: Jika pengembang perlu menggabungkan sejumlah besar string dengan pola yang kompleks atau bervariasi, StringJoiner mungkin tidak menjadi pilihan yang paling tepat. Dalam kasus seperti itu, penggunaan StringBuilder atau penyelesaian kustom mungkin lebih sesuai.
• Tidak Mendukung Operasi Penghapusan Tertentu: Meskipun pengembang dapat menghapus semua elemen menggunakan metode setEmptyValue() atau membuat ulang objek StringJoiner, tidak ada cara langsung untuk menghapus elemen tertentu berdasarkan indeks atau nilai tertentu dari StringJoiner. Jika operasi semacam itu diperlukan, Pengembang perlu menggunakan pendekatan yang lebih kompleks.

Meskipun demikian, untuk banyak kasus penggunaan, keuntungan StringJoiner jauh lebih besar daripada kerugiannya, membuatnya menjadi pilihan yang baik untuk kebutuhan penggabungan string dalam kode Java.

Kesimpulan

Dengan menggunakan StringJoiner, pengembang dapat menggabungkan string dengan cara yang lebih efisien, mengurangi overhead pembuatan objek yang tidak perlu. Ini membuatnya menjadi pilihan yang ideal ketika perlu menggabungkan sejumlah besar string dalam kode Java. Selain itu, StringJoiner memungkinkan fleksibilitas dalam menentukan delimiter, awalan, dan akhiran, membuatnya menjadi alat yang sangat berguna dalam pemrosesan string di Java.

Artikel ini didedikasikan kepada: Taufik Hidayat, Tegar Fachrurozi Suryakusuma, Thirza Ronaa Rachmawati, Urlia Purmalasari, dan Velina Claudya Ditarta.

Location: Kota Semarang, Jawa Tengah, Indonesia

Berbagi :