Java - Regular Expressions (Indonesia)

Selamat datang, para pemrogram Java yang aspiratif! Hari ini, kita akan menyelam ke dalam dunia yang menarik dari Regular Expressions (Regex) di Java. Jangan khawatir jika kamu masih baru dalam pemrograman; saya akan memandu kamu melalui perjalanan ini langkah demi langkah, sama seperti yang saya lakukan untuk banyak siswa selama tahun-tahun pengajaran saya. Jadi,ambil secangkir kopi, dan mari kita mulai petualangan yang menarik ini bersama-sama!

Apa itu Regular Expressions?

Sebelum kita melompat ke implementasi spesifik Java, mari kita mengerti apa itu Regular Expressions. Bayangkan jika kamu adalah detektif mencari pola spesifik di atas lautan teks. Itulah yang akan Regex lakukan – itu adalah alat yang kuat untuk pencocokan pola dan manipulasi string.

Kelas Regular Expressions (Regex) di Java

Java menyediakan sebuah paket yang disebut java.util.regex yang berisi beberapa kelas untuk bekerja dengan ekspresi reguler. Tiga kelas utama yang akan kita fokuskan adalah:

1. Pattern
2. Matcher
3. PatternSyntaxException

Mari kita eksplor masing-masing dari ini secara detil.

Kelas Pattern

Kelas Pattern mewakili representasi yang dikompilasi dari ekspresi reguler. Pikirkan tentang hal itu sebagai blueprint untuk pekerjaan detektif pencocokan pola kamu.

import java.util.regex.Pattern;

public class PatternExample {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("Hello");
System.out.println("Pattern dibuat: " + pattern);
}
}

Dalam contoh ini, kita membuat pola sederhana yang mencocokkan kata "Hello". Metode compile() mengambil ekspresi reguler sebagai string dan mengembalikan objek Pattern.

Kelas Matcher

Kelas Matcher adalah tempat dimana magi yang sebenarnya terjadi. Ini melakukan operasi pencocokan pada urutan karakter berdasarkan Pattern.

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

public class MatcherExample {
public static void main(String[] args) {
String text = "Hello, World! Hello, Java!";
Pattern pattern = Pattern.compile("Hello");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
System.out.println("Temukan kecocokan di indeks: " + matcher.start());
}
}
}

Kode ini mencari pola "Hello" di dalam teks yang diberikan dan mencetak indeks awal dari setiap kecocokan. Itu seperti detektif kita menemukan semua kemunculan dari sebuah clue di dalam dokumen!

Sintaks Regular Expression

Sekarang, mari kita pelajari beberapa sintaks dasar untuk membuat pola yang lebih kompleks. Berikut adalah tabel dari karakter meta yang umum digunakan:

Metacharacter	Deskripsi
.	Mencocokkan karakter tunggal apapun
^	Mencocokkan awal baris
$	Mencocokkan akhir baris
*	Mencocokkan nol atau lebih kemunculan
+	Mencocokkan satu atau lebih kemunculan
?	Mencocokkan nol atau satu kemunculan
\d	Mencocokkan digit
\s	Mencocokkan karakter spasi
\w	Mencocokkan karakter kata (huruf, digit, atau garis bawah)

Mari kita lihat beberapa dari ini dalam aksi:

public class RegexSyntaxExample {
public static void main(String[] args) {
String text = "The quick brown fox jumps over the lazy dog";

// Mencocokkan kata yang dimulai dengan 'q'
Pattern pattern1 = Pattern.compile("\\bq\\w+");
Matcher matcher1 = pattern1.matcher(text);
if (matcher1.find()) {
System.out.println("Kata yang dimulai dengan 'q': " + matcher1.group());
}

// Mencocokkan kata yang diakhiri dengan 'g'
Pattern pattern2 = Pattern.compile("\\w+g\\b");
Matcher matcher2 = pattern2.matcher(text);
if (matcher2.find()) {
System.out.println("Kata yang diakhiri dengan 'g': " + matcher2.group());
}
}
}

Dalam contoh ini, kita menggunakan \b untuk mencocokkan batas kata, \w+ untuk mencocokkan satu atau lebih karakter kata, dan menggabungkannya dengan 'q' dan 'g' untuk mencari kata yang dimulai dan diakhiri dengan 'q' dan 'g' masing-masing.

Grup Pencapture dalam Regular Expression

Grup pencapture memungkinkan kamu untuk memperlakukan beberapa karakter sebagai satu unit. Mereka dibuat dengan menempatkan karakter yang akan dikelompokkan di dalam tanda kurung.

public class CapturingGroupExample {
public static void main(String[] args) {
String text = "John Doe ([email protected])";
Pattern pattern = Pattern.compile("(\\w+)\\s(\\w+)\\s\\((\\w+@\\w+\\.\\w+)\\)");
Matcher matcher = pattern.matcher(text);

if (matcher.find()) {
System.out.println("Nama Depan: " + matcher.group(1));
System.out.println("Nama Belakang: " + matcher.group(2));
System.out.println("Email: " + matcher.group(3));
}
}
}

Dalam contoh ini, kita mengekstrak nama depan, nama belakang, dan alamat email dari sebuah string. Tanda kurung di dalam pola membuat grup pencapture, yang dapat diakses menggunakan matcher.group(n).

Regular Expression - Metode Kelas Matcher

Kelas Matcher menyediakan beberapa metode yang berguna. Berikut adalah beberapa yang paling umum digunakan:

Metode	Deskripsi
find()	Mencari kecocokan berikutnya untuk pola
group()	Mengembalikan substring yang cocok
start()	Mengembalikan indeks awal dari kecocokan
end()	Mengembalikan indeks akhir dari kecocokan
matches()	Memeriksa apakah seluruh string cocok dengan pola

Mari kita lihat metode ini dalam aksi:

public class MatcherMethodsExample {
public static void main(String[] args) {
String text = "The rain in Spain falls mainly on the plain";
Pattern pattern = Pattern.compile("\\b\\w+ain\\b");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
System.out.println("Ditemukan: " + matcher.group());
System.out.println("Indeks awal: " + matcher.start());
System.out.println("Indeks akhir: " + matcher.end());
}
}
}

Kode ini mencari semua kata yang diakhiri dengan "ain" dan mencetak setiap kecocokan beserta indeks awal dan akhirnya.

Regular Expression - Metode Penggantian

Ekspresi reguler tidak hanya untuk mencari pola; mereka juga sangat baik untuk mengganti teks. Kelas Matcher menyediakan metode untuk tujuan ini:

public class ReplacementExample {
public static void main(String[] args) {
String text = "The quick brown fox jumps over the lazy dog";
Pattern pattern = Pattern.compile("fox|dog");
Matcher matcher = pattern.matcher(text);

String result = matcher.replaceAll("animal");
System.out.println("Setelah penggantian: " + result);
}
}

Dalam contoh ini, kita mengganti baik "fox" dan "dog" dengan "animal". Metode replaceAll() melakukan semua pekerjaan yang susah untuk kita!

Regular Expression - Kelas PatternSyntaxException

Kadang-kadang, kita mungkin membuat kesalahan saat menulis ekspresi reguler kita. Itulah saat kelas PatternSyntaxException menjadi berguna. itu dilempar untuk menunjukkan kesalahan sintaks di dalam pola ekspresi reguler.

public class PatternSyntaxExceptionExample {
public static void main(String[] args) {
try {
Pattern.compile("[");  // Regex tidak valid
} catch (PatternSyntaxException e) {
System.out.println("Pengecualian sintaks pola: " + e.getMessage());
System.out.println("Indeks kesalahan: " + e.getIndex());
}
}
}

Kode ini secara sengaja menggunakan regex yang tidak valid untuk menunjukkan bagaimana PatternSyntaxException bekerja. Itu seperti memiliki penyunting internal untuk ekspresi reguler kamu!

Dan itu adalah semua, teman-teman! Kita telah berkeliling di atas negeri Java Regular Expressions, dari pola dasar ke penggantian kompleks. Ingat, seperti setiap alat yang kuat, regex menjadi lebih berguna jika kamu lebih sering melakukannya. Jadi, jangan takut untuk bereksperimen dan membuat pola kamu sendiri. Siapa tahu? Kamu mungkin menjadi Sherlock Holmes dari pencocokan pola!

Selamat coding, dan semoga string kamu selalu sesuai dengan ekspektasi kamu!

Credits: Image by storyset