Tutorial Coding Java: Menghapus Duplikat Karakter dari Sebuah String

Tutorial Coding Java: Menghapus Duplikat Karakter dari Sebuah String

Masalah “menghapus duplikat dari string” kelihatannya sepele. Banyak yang mikir, “ah ini mah cuma loop”. Tapi justru di soal kecil kayak gini, kelihatan jelas level pemahaman seorang programmer. Apakah cuma bikin kode jalan, atau benar-benar paham struktur data, kompleksitas, dan trade-off desain.

Di artikel ini, kita bakal membedah dua pendekatan untuk menghapus duplikat karakter dari string di Java:

1. Pendekatan manual dengan StringBuilder
2. Pendekatan berbasis struktur data Set(khususnya LinkedHashSet)

Keduanya valid. Keduanya sering muncul di interview. Tapi cara berpikir di baliknya beda kelas.

Masalah yang Akan Kita Selesaikan

Kita ingin membuat sebuah method yang:

• Menerima satu buah String
• Mengembalikan Stringbaru
• Karakter duplikat dihapus
• Urutan karakter tetap dipertahankan

Contoh:

• "hello"→ "helo"
• "apple"→ "aple"
• "aaaaaa"→ "a"
• "abc"→ "abc"

Catatan penting: Ini bukan soal mengurutkan karakter, tapi soal menyaring duplikat sambil menjaga urutan asli.

Baca Juga

• Cloneable Interface : Cara Java Menggandakan Diri
• Memahami C++ Lambda Expression

 

Struktur Kode Dasar

Mari kita lihat kerangka programnya dulu supaya konteksnya jelas.

package coding;

import java.util.LinkedHashSet;
import java.util.Set;


public class RemoveDuplicatesFromStr {
    public static void main(String[] args) {
        System.out.println(removeDup("hello")); // helo
        System.out.println(removeDup("apple")); // aple
        System.out.println(removeDup("aaaaaa")); // a
        System.out.println(removeDup("abc")); // abc
    }
}

Kita akan fokus ke dua method:

• removeDup
• removeDupWithSet

 

Pendekatan Pertama: Loop Manual dengan StringBuilder

Implementasi Kode

public static String removeDup(String str) {

    StringBuilder strNoDup = new StringBuilder();

 // loop over string and get each char
    for (char ch : str.toCharArray()) {
        // if strNoDup does not contain char then add to it
        if (!strNoDup.toString().contains(String.valueOf(ch))) {
            strNoDup.append(ch);
        }
    }


    return strNoDup.toString();
}

Sekarang kita bedah pelan-pelan, bukan cuma apa kodenya, tapi kenapa dia bekerja.

 

Cara Kerja Logika removeDup

Langkah mentalnya seperti ini:

1. Kita siapkan wadah kosong (StringBuilder)
2. Kita baca string karakter demi karakter
3. Setiap karakter dicek: Sudah pernah muncul belum?
4. Kalau belum, kita simpan
5. Kalau sudah, kita skip

Sederhana, tapi ada detail penting di sini.

 

Kenapa Pakai StringBuilder, Bukan String ?

Karena String di Java itu immutable. Setiap kali kamu melakukan operasi seperti:

result = result + ch;

Java akan:

• Membuat objek String baru
• Membuang yang lama
• Mengulang terus

Itu mahal. Boros memori. Boros waktu.

StringBuilder dibuat khusus untuk kasus seperti ini: merakit string secara bertahap.

Bagian Paling Krusial: contains()

if (!strNoDup.toString().contains(String.valueOf(ch))) {
    strNoDup.append(ch);
}

Di sinilah “jebakan halus” mulai muncul.

Setiap iterasi:

• toString()→ bikin String baru
• contains()→ scan seluruh isi string

Artinya?

• Kalau panjang string n
• Kompleksitas waktunya bisa mendekati O(n²)

Untuk string pendek: aman
Untuk string panjang: bisa jadi lambat

 

Kapan Pendekatan Ini Masih Masuk Akal?

Pendekatan ini masih valid kalau:

• String pendek
• Fokus ke kejelasan logika
• Lagi belajar dasar loop dan kondisi
• Interview level junior

Justru pendekatan ini bagus untuk:

• Melatih logika kontrol alur
• Melatih pemahaman karakter vs string
• Melatih penggunaan StringBuilder

Tapi… Java bukan cuma soal “bisa”.

 

Pendekatan Kedua: Menggunakan Set (LinkedHashSet)

Sekarang kita naik kelas.

Implementasi Kode

public static String removeDupWithSet(String str) {
    StringBuilder strNoDup = new StringBuilder();


    char[] letters = str.toCharArray();
    Set<Character> set = new LinkedHashSet<>();


    for (char ch : letters) {
        set.add(ch);
    }


    for (Character ch : set) {
        strNoDup.append(ch);
    }


    return strNoDup.toString();
}

Kelihatannya lebih panjang, tapi cara berpikirnya jauh lebih dewasa.

Kenapa Set ?

Karena Set punya satu janji penting:

Tidak boleh ada duplikat

Artinya:

• Kita tidak perlu manual cek contains
• Java yang jaga konsistensinya
• Lebih aman
• Lebih efisien

Kenapa LinkedHashSet, Bukan HashSet ?

Ini pertanyaan interview klasik.

• HashSet→ tidak menjamin urutan
• LinkedHashSet→ menyimpan urutan masuk

Karena kita ingin:

"hello" → h e l o

Bukan:

e h l o (acak)

Maka LinkedHashSet adalah pilihan yang tepat.

 

Alur Kerja removeDupWithSet

Secara mental, alurnya seperti ini:

1. Ubah string jadi array karakter
2. Masukkan satu per satu ke LinkedHashSet
3. Biarkan Set menghapus duplikat
4. Ambil kembali isi Set ke StringBuilder
5. Kembalikan hasilnya

Kita memisahkan tanggung jawab:

• Set → urusan duplikat
• StringBuilder → urusan output string

Ini ciri kode yang rapi.

Perbandingan Dua Pendekatan

Kalau diringkas secara konsep:

Pendekatan manual:

• Lebih sederhana
• Lebih intuitif
• Tapi kurang efisien

Pendekatan Set:

• Lebih deklaratif
• Lebih scalable
• Lebih “Java-style”

Dari Sudut Pandang Kompleksitas

Secara kasar:

• Pendekatan pertama → O(n²)
• Pendekatan kedua → mendekati O(n)

Kalau string kamu panjang, beda performanya kerasa banget.

Versi Aman untuk Production Code

Kalau kamu nulis kode untuk:

• Sistem backend
• Aplikasi besar
• Library umum

Pendekatan LinkedHashSet jauh lebih aman dan profesional.

Versi Singkat dan Bersih (Refactor)

Sedikit dirapikan tanpa mengubah logika:

public static String removeDupWithSet(String str) {

 Set<Character> set = new LinkedHashSet<>();
    for (char ch : str.toCharArray()) {
        set.add(ch);
    }


    StringBuilder result = new StringBuilder();
    for (char ch : set) {
        result.append(ch);
    }


    return result.toString();
}

Lebih bersih, lebih kebaca.

 

Pelajaran Besar dari Soal Sederhana Ini

Soal sederhana seperti menghapus duplikat dari string sering dianggap cuma latihan pemanasan. Padahal justru di sinilah fondasi cara berpikir programmer kelihatan jelas. Dari satu problem kecil, kita dipaksa memilih: mau memaksa logika sendiri dengan loop dan kondisi, atau mau memanfaatkan struktur data yang memang diciptakan untuk tujuan tertentu. Di titik ini, pemilihan struktur data bukan lagi soal “bisa atau tidak”, tapi soal tepat atau tidak. Set ada bukan tanpa alasan, dan ketika kita sadar bahwa masalah duplikat adalah domainnya Set, kita sedang belajar berpikir selaras dengan bahasa dan ekosistem Java.

Soal ini juga menampar perbedaan halus tapi krusial antara kode yang sekadar “jalan” dan kode yang bisa disebut “baik”. Kode yang jalan itu mudah: asal output benar, selesai. Tapi kode yang baik itu bisa dibaca ulang tanpa mikir keras, bisa dijelaskan ke orang lain tanpa drama, dan masih masuk akal ketika dilihat lagi enam bulan kemudian. Pendekatan berbasis API Java, seperti LinkedHashSet, menunjukkan bagaimana bahasa ini sengaja menyediakan alat agar programmer tidak perlu mengulang kesalahan yang sama. Java tidak memaksa kita jadi pintar, tapi dia menghadiahi kita kalau mau berpikir rapi.

Pada akhirnya, pelajaran terbesarnya bukan soal string atau karakter, tapi soal niat di balik kode. Kode elegan bukan yang paling singkat, bukan juga yang paling “pinter kelihatannya”, melainkan yang paling jujur menjelaskan apa yang ingin dilakukan. Ketika membaca kode, orang lain (termasuk diri kita di masa depan) seharusnya langsung paham: “oh, ini soal menghapus duplikat, makanya pakai Set”. Kalau sampai logikanya harus ditebak-tebak, berarti yang kurang bukan kemampuan ngoding, tapi kejelasan desain. Dan dari soal receh inilah, mental model programmer pelan-pelan naik kelas.

 

Penutup: Dari Loop ke Cara Berpikir

Menghapus duplikat string bukan tentang karakter, tapi tentang cara berpikir programmer. Programmer pemula fokus ke “gimana caranya”. Programmer yang lebih matang mulai mikir “siapa yang paling cocok ngerjain tugas ini”.

Kalau kamu sudah refleks mikir:

“Oh, ini urusan Set”

Berarti kamu bukan cuma bisa Java kamu paham Java.

Published on March 19, 2026
Last updated on June 03, 2026