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

1. Pengenalan: Mengapa Pencarian String Penting di Java

Manipulasi string adalah salah satu operasi yang paling sering digunakan saat memprogram di 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 yang lain. 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 lain. 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

Mengirim 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 besar) sebelum perbandingan:

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

Pendekatan ini membantu menghilangkan perbedaan dalam huruf kapital 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 akan terjadi NullPointerException.

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
}

Catatan tambahan:
Menyertakan 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 diberikan secara tidak sengaja.

3-4. Tidak Mendukung Pencarian Banyak Kata Kunci

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 kumpulan 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 sebuah substring tertentu ada.
Di antaranya, contains() digunakan untuk “pencokan parsial,” namun metode lain juga memiliki tujuan serupa.
Bagian ini menjelaskan karakteristik dan perbedaan metode tersebut agar Anda dapat menggunakannya dengan tepat.

4-1. Perbedaan dengan equals(): Kecocokan Tepat vs. Kecocokan Parsial

equals() menentukan apakah dua string identik secara tepat.
Sebaliknya, contains() memeriksa kecocokan 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 kecocokan parsial dapat diterima (misalnya, pencarian kata kunci).

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

Metode indexOf() juga dapat digunakan untuk memeriksa apakah sebuah substring ada dalam sebuah string.
Perbedaannya, 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 meniru perilaku contains():

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

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

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

Metode matches() memeriksa apakah sebuah string sepenuhnya cocok dengan ekspresi reguler yang diberikan.
Sebaliknya, contains() hanya memeriksa kecocokan 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 menginginkan pencocokan parsial berbasis regex, gunakan kelas Pattern:

4-4. Ringkasan Perbandingan Fitur

5. Kasus Penggunaan Umum dan Contoh Kode

Metode contains() Java sederhana namun banyak digunakan dalam skenario pengembangan nyata.
Kasus penggunaan tipikal meliputi validasi input pengguna, analisis log, dan operasi penyaringan.
Bagian ini mencakup contoh praktis dengan kode yang bersesuaian.

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

Dalam formulir atau aplikasi obrolan, Anda mungkin perlu mendeteksi apakah kata-kata terlarang tertentu disertakan.

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 berisi 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. Memfilter String dalam Daftar (Menggunakan Stream API)

Saat menangani dataset besar, gunakan Stream API untuk mengekstrak hanya elemen yang berisi substring spesifik:

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. Mengurai Header Permintaan HTTP atau URL

Dalam pengembangan web, routing atau penanganan spesifik perangkat mungkin memerlukan pemeriksaan substring dalam 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 jenis 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") sering kali lebih akurat.

Pertimbangan Praktis

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

6. Pertimbangan Performa

Meskipun metode contains() menawarkan keterbacaan dan kesederhanaan yang sangat baik, Anda harus mempertimbangkan dampak performa-nya saat menangani dataset besar atau menjalankan operasi berulang. Bagian ini menjelaskan biaya pemrosesan contains() dan pendekatan alternatif untuk efisiensi yang lebih baik.

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 memengaruhi performa secara signifikan saat diulang dalam loop besar.

6-2. Teknik untuk Meningkatkan Performa Saat Pencarian yang Sering

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

• Konversi semua string ke huruf kecil terlebih dahulu

Alih-alih memanggil toLowerCase() selama 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 kompleks

If the conditions are complex and can be expressed in one regex, Pattern may perform better:

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

6-3. Pertimbangan Efisiensi Memori dan Daur Ulang

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

• Hindari membuat instance string yang tidak diperlukan.
• Untuk dataset besar, pertimbangkan buffering atau pemrosesan dalam potongan.
• Menyimpan 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 pengecekan 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 yang 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 menimbulkan pengecualian; cukup mengembalikan false.
• includes() juga berfungsi pada array, menambah 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() di C# sensitif huruf besar/kecil secara default, tetapi Anda dapat mengabaikan kasus dengan StringComparison.OrdinalIgnoreCase.
• Memberikan null memicu ArgumentNullException.

7-4. Tabel Perbandingan Antara Bahasa

Ringkasan: Pilih Sintaks yang Tepat untuk Kasus Penggunaan Anda

Meskipun pengecekan substring merupakan kebutuhan umum di semua bahasa, setiap bahasa menyediakan metode atau sintaksnya masing‑masing. contains() Java menawarkan stabilitas dan kejelasan, sehingga cocok untuk sistem enterprise dan aplikasi yang mudah dipelihara. Bahasa seperti Python dan JavaScript menawarkan sintaks yang lebih sederhana dan ringkas, yang ideal untuk skr atau prototipe cepat. Dengan memahami konsep umum fitur spesifik tiap bahasa, Anda dapat menulis kode yang lebih aman dan efisien di berbagai platform.

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() membedakan huruf besar/kecil?

Ya, ia membedakan huruf besar/kecil.
Misalnya, "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?

A NullPointerException akan dilemparkan.

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 tak terduga jika string kosong tidak dimaksudkan.

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

Tidak. Setiap pemanggilan hanya memeriksa 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 nilai boolean, sedangkan indexOf() mengembalikan indeks numerik.

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

  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 yang kuat dan praktis untuk menentukan apakah sebuah substring terdapat dalam sebuah string.
Metode ini banyak digunakan dalam berbagai skenario seperti validasi pengguna, analisis log, dan penyaringan data.
Dalam artikel ini, kami membahas:

• Sintaks dasar dan nilai kembaliannya
• 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 optimasi
• Perbandingan dengan Python, JavaScript, dan C#
• Pertanyaan yang sering diajukan serta tips pemecahan masalah

Meskipun contains() intuitif dan serbaguna, penggunaannya harus dievaluasi dengan hati-hati pada kasus 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 kode.
Karena contains() merupakan dasar dalam bekerja dengan string di Java, kami berharap artikel ini membantu Anda menggunakannya dengan lebih aman dan efektif dalam proyek pengembangan Anda.