Menguasai contains() di Java: Cara Melakukan Pencarian Substring yang Efisien

1. Pengantar: Mengapa Pencarian String Penting dalam Java

Manipulasi string adalah salah satu operasi yang paling sering digunakan saat memprogram dalam Java.
Baik memeriksa input pengguna, mengurai isi file, atau mencari kata kunci tertentu, Anda sering perlu menentukan apakah kata tertentu terkandung dalam string yang diberikan.

Untuk memenuhi kebutuhan ini, Java menyediakan metode yang nyaman yang disebut contains().
Dengan metode ini, Anda dapat dengan mudah menentukan apakah satu string mengandung sebagian string lainnya.
Misalnya, jika Anda ingin memeriksa apakah pesan kesalahan mengandung kata kunci tertentu, contains() memungkinkan Anda melakukannya dalam satu baris kode.

Terutama dalam skenario yang melibatkan volume teks yang besar—seperti aplikasi web, pemrosesan API, atau analisis log—metode contains() sangat meningkatkan keterbacaan dan kemudahan pemeliharaan kode.
Namun, ada juga pertimbangan penting seperti sensitivitas huruf besar-kecil dan kemungkinan null.

Artikel ini menjelaskan metode contains() Java secara detail—dari penggunaan dasar dan kesalahan umum hingga perbedaan dengan metode lain dan aplikasi praktis.
Tujuan kami adalah menyediakan informasi yang berguna tidak hanya untuk pemula tetapi juga untuk pengembang yang secara aktif menggunakan Java dalam proyek dunia nyata.

2. Sintaks Dasar dan Karakteristik Metode contains()

Metode contains() Java menentukan apakah sebuah string mengandung sebagian string lainnya.
Sintaksnya sangat sederhana, namun sangat praktis dan sering digunakan dalam tugas pemrograman sehari-hari.

Sintaks Dasar

boolean result = targetString.contains(searchString);

Metode ini termasuk dalam kelas String dan menerima CharSequence (umumnya String) sebagai argumennya.
Nilai kembaliannya adalah boolean: true jika string target mengandung substring yang diberikan, dan false jika tidak.

Contoh Kode

String message = "Java programming is fun!";
boolean hasKeyword = message.contains("programming");

System.out.println(hasKeyword); // Output: true

Dalam contoh di atas, substring "programming" ada dalam string target, sehingga contains() mengembalikan true.

Karakteristik Metode

• Hanya memeriksa kecocokan sebagian: Jika Anda membutuhkan kecocokan yang tepat, gunakan equals() sebagai gantinya.
• Sensitif terhadap huruf besar-kecil: Misalnya, "Java" dan "java" diperlakukan sebagai berbeda (detail dijelaskan nanti).
• Tidak mendukung ekspresi reguler: Karena hanya memeriksa keberadaan string, pencocokan pola memerlukan matches() atau kelas Pattern.

Perilaku Saat null Diberikan

Meneruskan null ke contains() memicu NullPointerException.
Misalnya, kode berikut akan melemparkan pengecualian:

String text = null;
System.out.println(text.contains("test")); // Exception occurs

Demikian pula, jika string target itu sendiri adalah null, pengecualian yang sama akan dilemparkan.
Oleh karena itu, sangat disarankan untuk melakukan pemeriksaan null sebelum memanggil contains().

3. Contoh Penggunaan Praktis dan Pertimbangan Penting

Metode contains() Java sangat intuitif dan nyaman, tetapi penggunaan yang salah dapat menyebabkan bug tak terduga atau kode yang tidak efisien.
Bagian ini menjelaskan penggunaan dasar contains() beserta poin-poin kunci yang harus Anda ketahui.

3-1. Contoh Penggunaan Dasar

Kode berikut mendemonstrasikan contoh sederhana untuk memeriksa apakah string target mengandung kata kunci tertentu:

String sentence = "今日はJavaの勉強をしています。";

if (sentence.contains("Java")) {
    System.out.println("Javaが含まれています。");
} else {
    System.out.println("Javaは含まれていません。");
}

Seperti yang ditunjukkan, contains() sering dikombinasikan dengan pernyataan if untuk melakukan percabangan kondisional.

3-2. Sensitivitas Huruf Besar-Kecil

Metode contains() sensitif terhadap huruf besar-kecil.
Misalnya, kode berikut mengembalikan false:

String text = "Welcome to Java";
System.out.println(text.contains("java")); // false

Dalam kasus seperti itu, umum untuk mengonversi string ke huruf kecil (atau huruf besar) sebelum perbandingan:

String text = "Welcome to Java";
System.out.println(text.toLowerCase().contains("java")); // true

Pendekatan ini membantu menghilangkan perbedaan dalam kasus input (misalnya, input pengguna).

3-3. Penanganan null dan String Kosong

Salah satu pertimbangan terpenting saat menggunakan contains() adalah penanganan null.
Jika string target atau argumen adalah null, maka NullPointerException akan terjadi.

String text = null;
System.out.println(text.contains("test")); // Runtime error

Untuk menghindari masalah ini, selalu tambahkan pemeriksaan null:

if (text != null && text.contains("test")) {
    // Safe to process
}

Juga perhatikan:
Meneruskan string kosong ("") selalu mengembalikan true.

String sample = "test";
System.out.println(sample.contains("")); // true

Namun, perilaku ini jarang berguna dalam praktik dan dapat secara tidak sengaja menyebabkan bug jika string kosong diteruskan secara tidak disengaja.

3-4. Tidak Mendukung Pencarian Kata Kunci Ganda

contains() hanya dapat memeriksa satu kata kunci pada satu waktu.
Untuk memeriksa beberapa kata kunci, Anda harus memanggil contains() beberapa kali atau menggunakan Stream API.

String target = "エラーコード123：アクセス拒否";
if (target.contains("エラー") || target.contains("拒否")) {
    System.out.println("問題のあるメッセージです。");
}

Atau, untuk set kata kunci dinamis:

List<String> keywords = Arrays.asList("エラー", "障害", "失敗");
boolean found = keywords.stream().anyMatch(target::contains);

4. Metode yang Sering Dibandingkan dengan contains()

Java menyediakan beberapa metode untuk membandingkan string atau memeriksa apakah substring tertentu ada.
Di antara mereka, contains() digunakan untuk “pencocokan parsial,” tetapi metode lain juga memiliki tujuan serupa.
Bagian ini menjelaskan karakteristik dan perbedaan metode-metode tersebut untuk membantu Anda menggunakannya secara tepat.

4-1. Perbedaan dari equals(): Pencocokan Tepat vs. Pencocokan Parsial

equals() menentukan apakah dua string identik secara tepat.
Sebaliknya, contains() memeriksa pencocokan parsial.

String a = "Java";
String b = "Java";

System.out.println(a.equals(b));      // true: Exact match
System.out.println(a.contains("av")); // true: Partial match

Perbedaan utama:

Panduan Penggunaan:
Gunakan equals() ketika nilai harus cocok secara tepat (misalnya, verifikasi ID).
Gunakan contains() ketika pencocokan parsial dapat diterima (misalnya, pencarian kata kunci).

4-2. Perbedaan dari indexOf(): Apakah Anda Membutuhkan Posisi

Metode indexOf() juga dapat digunakan untuk memeriksa apakah substring ada dalam string.
Perbedaannya adalah indexOf() mengembalikan indeks awal dari substring jika ditemukan.
Jika substring tidak ditemukan, ia mengembalikan -1.

String text = "Hello, Java World!";
System.out.println(text.indexOf("Java"));    // 7
System.out.println(text.indexOf("Python"));  // -1

Anda juga dapat menggunakan indexOf() untuk mereplikasi perilaku contains():

if (text.indexOf("Java") >= 0) {
    System.out.println("It is contained.");
}

Panduan penggunaan:
Jika Anda tidak membutuhkan indeks, contains() lebih mudah dibaca dan lebih disukai.

4-3. Perbedaan dari matches(): Dukungan untuk Ekspresi Reguler

Metode matches() memeriksa apakah string sepenuhnya cocok dengan ekspresi reguler yang diberikan.
Sebaliknya, contains() hanya memeriksa pencocokan substring literal dan tidak mendukung regex.

String text = "abc123";
System.out.println(text.matches(".*123")); // true
System.out.println(text.contains(".*123")); // false (not regex)

Jika Anda ingin pencocokan parsial berbasis regex, gunakan kelas Pattern:

4-4. Ringkasan Perbandingan Fitur

5. Kasus Penggunaan Umum dan Contoh Kode

answer.Java’s contains() method is simple yet widely used in real development scenarios.
Typical use cases include user input validation, log analysis, and filtering operations.
This section covers practical examples with corresponding code.

5-1. Validasi Input Pengguna (Mendeteksi Kata Terlarang)

Dalam formulir atau aplikasi obrolan, Anda mungkin perlu mendeteksi apakah kata‑kata terlarang tertentu termasuk di dalamnya.

String input = "このアプリは最悪だ";
String banned = "最悪";

if (input.contains(banned)) {
    System.out.println("不適切な言葉が含まれています。");
}

Menangani beberapa kata NG:

List<String> bannedWords = Arrays.asList("最悪", "バカ", "死ね");
for (String word : bannedWords) {
    if (input.contains(word)) {
        System.out.println("不適切な言葉が含まれています: " + word);
        break;
    }
}

5-2. Analisis File Log (Mendeteksi Pesan Spesifik)

Saat menganalisis log sistem atau aplikasi, Anda mungkin ingin mengekstrak hanya baris yang mengandung kata kunci spesifik seperti ERROR atau WARN.

List<String> logs = Arrays.asList(
    "[INFO] サーバーが起動しました",
    "[ERROR] データベース接続失敗",
    "[WARN] メモリ使用率が高い"
);

for (String log : logs) {
    if (log.contains("ERROR")) {
        System.out.println("エラー発生ログ: " + log);
    }
}

5-3. Menyaring String dalam Daftar (Menggunakan Stream API)

Saat menangani dataset besar, gunakan Stream API untuk mengekstrak hanya elemen yang mengandung substring tertentu:

List<String> users = Arrays.asList("tanaka@example.com", "sato@gmail.com", "yamada@yahoo.co.jp");

List<String> gmailUsers = users.stream()
    .filter(email -> email.contains("@gmail.com"))
    .collect(Collectors.toList());

System.out.println(gmailUsers); // [sato@gmail.com]

5-4. Menganalisis Header Permintaan HTTP atau URL

Dalam pengembangan web, routing atau penanganan khusus perangkat mungkin memerlukan pemeriksaan substring pada User-Agent atau URL.

String userAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X)";
if (userAgent.contains("iPhone")) {
    System.out.println("スマートフォンからのアクセスです。");
}

5-5. Memeriksa Jalur File atau Ekstensi

Untuk menentukan tipe file menggunakan jalurnya:

String filePath = "/usr/local/data/sample.csv";
if (filePath.contains(".csv")) {
    System.out.println("CSVファイルです。");
}

Catatan:
Untuk pemeriksaan ekstensi file, endsWith(".csv") seringkali lebih akurat.

Pertimbangan Praktis

• Terapkan normalisasi (mis., toLowerCase(), trim()) ketika akurasi diperlukan.
• Untuk data berskala besar, pertimbangkan Stream API atau regex.
• Ingat bahwa contains() adalah pencocokan parsial—gabungkan dengan kondisi lain untuk logika yang lebih aman.

6. Pertimbangan Kinerja

Meskipun metode contains() menawarkan keterbacaan dan kesederhanaan yang luar biasa, Anda harus mempertimbangkan dampak kinerjanya saat menangani dataset besar atau menjalankan operasi berulang. Bagian ini menjelaskan biaya pemrosesan contains() dan pendekatan alternatif untuk meningkatkan efisiensi.

6-1. Perilaku Internal dan Kompleksitas Waktu contains()

Metode contains() mencari string target secara berurutan dari awal untuk menemukan substring. Secara internal, ia bergantung pada metode indexOf(), dan kompleksitas waktu terburuknya adalah:

O(n * m)
– n = panjang string target
– m = panjang string pencarian

Contoh pemrosesan berat:

for (String line : hugeTextList) {
    if (line.contains("error")) {
        // processing
    }
}

Ini dapat secara signifikan memengaruhi kinerja ketika diulang dalam loop besar.

6-2. Teknik untuk Meningkatkan Kinerja pada Pencarian Sering

Saat menggunakan contains() berulang kali dalam dataset besar, teknik berikut dapat meningkatkan kecepatan pemrosesan:

• Konversi semua string ke huruf kecil terlebih dahulu

Alih-alih memanggil toLowerCase() pada setiap perbandingan, normalisasi string terlebih dahulu:

List<String> normalizedList = originalList.stream()
    .map(String::toLowerCase)
    .collect(Collectors.toList());

• Gunakan Stream API dengan parallel() untuk pemrosesan paralel

Manfaatkan inti CPU untuk mempercepat pencarian:

List<String> result = hugeTextList.parallelStream()
    .filter(line -> line.contains("keyword"))
    .collect(Collectors.toList());

• Gunakan ekspresi reguler untuk pola pencarian yang kompleks

Jika kondisi kompleks dan dapat diekspresikan dalam satu regex, Pattern mungkin bekerja lebih baik:

Pattern pattern = Pattern.compile("error|fail|fatal");
for (String log : logs) {
    if (pattern.matcher(log).find()) {
        // matched
    }
}

6-3. Pertimbangan Efisiensi Memori dan Dapat Digunakan Kembali

Operasi yang sering mengonversi string—seperti toLowerCase() atau substring()—dapat menghasilkan banyak objek string yang tidak diperlukan, yang memengaruhi penggunaan memori.
Hal ini terutama penting untuk aplikasi yang berjalan lama atau pemrosesan sisi server.

Poin penting:

• Hindari membuat instance string yang tidak diperlukan.
• Untuk dataset besar, pertimbangkan buffering atau pemrosesan dalam potongan.
• Menyimpan cache hasil contains() yang berulang dapat meningkatkan kinerja dalam kasus tertentu.

7. Perbandingan dengan Bahasa Pemrograman Lain

Metode contains() Java menawarkan pencocokan substring yang sederhana dan dapat diandalkan, tetapi bahasa lain menyediakan fitur serupa dengan karakteristik masing-masing.
Bagian ini membandingkan pemeriksaan substring di Python, JavaScript, dan C# untuk menyoroti perbedaan dan kesamaan.

7-1. Python: Pencocokan Parsial Sederhana dengan Operator in

Di Python, Anda dapat memeriksa inklusi substring menggunakan operator in:

text = "Hello, Python!"
if "Python" in text:
    print("含まれています")

Sintaks ini sangat mudah dibaca—hampir seperti bahasa alami—dan memerlukan pembelajaran minimal.

Perbedaan dan Catatan:

• in adalah operator bahasa, bukan metode.
• Python juga sensitif huruf besar/kecil untuk perbandingan string.
• None menghasilkan pengecualian; pemeriksaan null diperlukan.

7-2. JavaScript: Pencocokan Parsial dengan includes()

Di JavaScript (ES6+), Anda dapat menggunakan metode includes():

const text = "JavaScript is fun";
console.log(text.includes("fun")); // true

Metode ini sangat mirip dengan contains() Java dan mudah dipindahkan secara mental.

Perbedaan dan Catatan:

• Memberikan undefined tidak melempar pengecualian; ia hanya mengembalikan false.
• includes() juga berfungsi pada array, meningkatkan fleksibilitasnya.

7-3. C#: Contains() Mirip dengan Java

C# juga menyediakan metode Contains() dengan perilaku yang mirip dengan Java:

string text = "Welcome to C#";
bool result = text.Contains("C#");

Perbedaan dan Catatan:

• Contains() C# sensitif huruf besar/kecil secara default, tetapi Anda dapat mengabaikan huruf dengan menggunakan StringComparison.OrdinalIgnoreCase.
• Memberikan null memicu ArgumentNullException.

7-4. Tabel Perbandingan Antara Bahasa

Ringkasan: Pilih Sintaks yang Tepat untuk Kasus Penggunaan Anda

Meskipun pemeriksaan substring adalah kebutuhan umum di semua bahasa, setiap bahasa menyediakan metode atau sintaksnya masing-masing.
contains() Java menawarkan stabilitas dan kejelasan, menjadikannya cocok untuk sistem perusahaan dan aplikasi yang dapat dipelihara.
Bahasa seperti Python dan JavaScript menawarkan sintaks yang lebih sederhana dan ringkas, yang dapat ideal untuk skrip ringan atau prototipe cepat.

Dengan memahami baik konsep umum maupun fitur spesifik masing-masing bahasa, Anda akan dapat menulis kode yang lebih aman dan efisien di berbagai bahasa.

8. Pertanyaan yang Sering Diajukan (FAQ)

Berikut adalah pertanyaan yang sering diajukan mengenai metode contains() Java—membantu Anda memahami poin-poin rumit dan menghindari jebakan umum.

Q1. Apakah contains() sensitif huruf besar/kecil?

Ya, ia sensitif huruf besar/kecil.
Sebagai contoh, "Java".contains("java") mengembalikan false.

Solusi:

String input = "Welcome to Java";
boolean result = input.toLowerCase().contains("java");

Q2. Bagaimana cara memeriksa pencocokan parsial menggunakan ekspresi reguler?

contains() tidak mendukung ekspresi reguler.
Gunakan matches() atau kelas Pattern sebagai gantinya.

Contoh (memeriksa pola numerik):

import java.util.regex.Pattern;
import java.util.regex.Matcher;

String text = "注文番号: A123456";
Pattern pattern = Pattern.compile("A\\d+");
Matcher matcher = pattern.matcher(text);

if (matcher.find()) {
    System.out.println("パターンに一致しました。");
}

Q3. Apa yang terjadi jika saya memanggil contains() pada null?

Akan dilemparkan NullPointerException.

String target = null;
System.out.println(target.contains("test")); // Error

Solusi:

if (target != null && target.contains("test")) {
    System.out.println("含まれています。");
}

Q4. Apa yang terjadi jika saya memberikan string kosong (“”) ke contains()?

Selalu mengembalikan true.

String text = "Java";
System.out.println(text.contains("")); // true

Meskipun merupakan bagian dari spesifikasi resmi, perilaku ini jarang berguna dan dapat menyebabkan bug yang tidak terduga jika string kosong tidak dimaksudkan.

Q5. Bisakah contains() mencari beberapa kata kunci sekaligus?

Tidak. Setiap pemanggilan memeriksa hanya satu kata kunci.

String text = "本日はシステムエラーが発生しました";
if (text.contains("エラー") || text.contains("障害") || text.contains("失敗")) {
    System.out.println("問題が検出されました。");
}

Pendekatan dinamis:

List<String> keywords = Arrays.asList("エラー", "障害", "失敗");
boolean found = keywords.stream().anyMatch(text::contains);

Q6. Kapan saya harus menggunakan contains() vs indexOf()?

contains() mengembalikan boolean, sedangkan indexOf() mengembalikan indeks numerik.

• Gunakan contains() ketika Anda hanya ingin mengetahui apakah substring ada.
• Gunakan indexOf() ketika Anda juga membutuhkan posisi.

  String text = "Error: Disk full";
  if (text.contains("Error")) {
      int pos = text.indexOf("Error");
      System.out.println("Position: " + pos);
  }
  

9. Kesimpulan

Metode contains() Java adalah alat yang kuat dan nyaman untuk menentukan apakah sebuah substring tertentu terdapat dalam sebuah string.
Metode ini banyak digunakan dalam berbagai skenario seperti validasi input pengguna, analisis log, dan penyaringan data.

Dalam artikel ini, kami membahas:

• Sintaks dasar dan nilai kembali
• Sensitivitas huruf besar/kecil dan cara menanganinya
• Penanganan null dan string kosong
• Perbedaan dengan metode perbandingan string lainnya
• Kasus penggunaan praktis: validasi, pencarian log, pemrosesan Stream
• Pertimbangan kinerja dan teknik optimisasi
• Perbandingan dengan Python, JavaScript, dan C#
• Pertanyaan yang sering diajukan dan tips pemecahan masalah

Meskipun contains() intuitif dan serbaguna, penggunaannya harus dievaluasi dengan hati-hati dalam kasus yang melibatkan dataset besar, pemanggilan yang sering, atau kondisi pencarian yang kompleks.
Dengan menggabungkan normalisasi, pemrosesan paralel, regex, dan strategi caching, Anda dapat mempertahankan kinerja sekaligus keterbacaan.

Karena contains() merupakan hal mendasar dalam bekerja dengan string di Java, kami berharap artikel ini membantu Anda menggunakannya dengan lebih aman dan efektif dalam proyek pengembangan Anda.