Ekspresi reguler Java

Ekspresi reguler mendefinisikan pola string.

Ekspresi reguler dapat digunakan untuk mencari, mengedit, atau memanipulasi teks.

Ekspresi reguler tidak terbatas pada satu bahasa, namun terdapat perbedaan halus dalam setiap bahasa.

Ekspresi reguler Java paling mirip dengan Perl.

Paket java.util.regex terutama mencakup tiga kelas berikut:

• Kelas pola:

  Objek pola adalah representasi ekspresi reguler yang dikompilasi. Kelas pola tidak memiliki konstruktor publik. Untuk membuat objek Pola, Anda harus terlebih dahulu memanggil metode kompilasi statis publiknya, yang akan mengembalikan objek Pola. Metode ini menerima ekspresi reguler sebagai parameter pertamanya.

• Kelas pencocokan:

  Objek Matcher adalah mesin yang menafsirkan dan mencocokkan string masukan. Seperti kelas Pattern, Matcher tidak memiliki konstruktor publik. Anda perlu memanggil metode matcher dari objek Pattern untuk mendapatkan objek Matcher.

• Pengecualian Sintaks Pola:

  PatternSyntaxException adalah kelas pengecualian tidak wajib yang mewakili kesalahan sintaksis dalam pola ekspresi reguler.

Menangkap kelompok

Menangkap grup adalah cara untuk memperlakukan beberapa karakter sebagai satu unit, dibuat dengan mengelompokkan karakter dalam tanda kurung.

Misalnya, ekspresi reguler (anjing) membuat satu grup yang berisi "d", "o", dan "g".

Kelompok penangkap diberi nomor dengan menghitung tanda kurung buka dari kiri ke kanan. Misalnya, dalam ekspresi ((A)(B(C))), ada empat grup seperti itu:

• ((A)(B(C)))

• (A)

• (B(C))

• (C)

Anda dapat memeriksa berapa banyak grup yang dimiliki suatu ekspresi dengan memanggil metode groupCount dari objek matcher. Metode groupCount mengembalikan nilai int, yang menunjukkan bahwa objek pencocokan saat ini memiliki beberapa grup penangkap.

Ada juga grup khusus (grup 0) yang selalu mewakili keseluruhan ekspresi. Grup tidak termasuk dalam nilai kembalian groupCount.

Contoh

Contoh berikut menunjukkan cara menemukan serangkaian digit dari string tertentu:

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

RegexMatches kelas publik
{
public static void main( String args[] ){

// Cari string berdasarkan pola yang ditentukan String line = "Pesanan ini dilakukan untuk QT3000! OK?";
Pola string = "(.*)(\d+)(.*)";

//Membuat objek Pola Pola r = Pattern.compile(pattern);

// Sekarang buat objek matcher Matcher m = r.matcher(line);
jika (m.temukan( )) {
System.out.println("Nilai yang ditemukan: " + m.group(0) );
System.out.println("Nilai yang ditemukan: " + m.group(1) );
System.out.println("Nilai yang ditemukan: " + m.group(2) );
} kalau tidak {
System.out.println("TIDAK COCOK");
}
}
}

Hasil kompilasi dan running dari contoh di atas adalah sebagai berikut:

 Nilai yang ditemukan: Pesanan ini dilakukan seharga QT3000!
Nilai yang ditemukan: Pesanan ini dilakukan untuk QT300
Nilai yang ditemukan: 0

Sintaks ekspresi reguler

Metode kelas Matcher

Metode indeks

Metode indeks memberikan nilai indeks berguna yang menunjukkan dengan tepat di mana kecocokan ditemukan dalam string masukan:

metode penelitian

Metode penelitian memeriksa string masukan dan mengembalikan nilai Boolean yang menunjukkan apakah pola tersebut ditemukan:

metode penggantian

Metode penggantian adalah metode untuk mengganti teks pada string masukan:

metode awal dan akhir

Berikut adalah contoh penghitungan jumlah kemunculan kata "cat" dalam string input:

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

RegexMatches kelas publik
{
String akhir statis pribadi REGEX = "\bcat\b";
String akhir statis pribadi INPUT =
"kucing kucing kucing kucing kucing";

public static void main( String args[] ){
Pola p = Pattern.compile(REGEX);
Pencocokan m = p.matcher(INPUT); // Dapatkan objek pencocokan int count = 0;

while(m.find()) {
hitungan++;
System.out.println("Nomor yang cocok "+hitungan);
Sistem.keluar.println("mulai(): "+m.mulai());
Sistem.keluar.println("end(): "+m.end());
}
}
}

Hasil kompilasi dan running dari contoh di atas adalah sebagai berikut:

 Pertandingan nomor 1
mulai(): 0
akhir(): 3
Pertandingan nomor 2
mulai(): 4
akhir(): 7
Pertandingan nomor 3
mulai(): 8
akhir(): 11
Pertandingan nomor 4
mulai(): 19
akhir(): 22

Anda dapat melihat bahwa contoh ini menggunakan batasan kata untuk memastikan bahwa huruf "c" "a" "t" bukan sekadar substring dari kata yang lebih panjang. Ini juga memberikan beberapa informasi berguna tentang di mana dalam string input kecocokan terjadi.

Metode awal mengembalikan indeks awal dari urutan yang ditangkap oleh grup tertentu selama operasi pencocokan sebelumnya, dan metode akhir menambahkan satu ke indeks karakter terakhir yang cocok.

kecocokan dan metode mencari

Metode match dan searchingAt keduanya digunakan untuk mencoba mencocokkan pola urutan masukan. Perbedaan di antara keduanya adalah bahwa pencocokan memerlukan seluruh urutan untuk dicocokkan, sedangkan searchingAt tidak.

Kedua metode ini sering digunakan di awal string masukan.

Kami menggunakan contoh berikut untuk menjelaskan fungsi ini:

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

RegexMatches kelas publik
{
String akhir statis pribadi REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
pola Pola statis pribadi;
pencocokan Pencocokan statis pribadi;

public static void main( String args[] ){
pola = Pola.kompilasi(REGEX);
matcher = pola.matcher(INPUT);

System.out.println("REGEX saat ini adalah: "+REGEX);
System.out.println("INPUT saat ini adalah: "+INPUT);

System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}

Hasil kompilasi dan running dari contoh di atas adalah sebagai berikut:

 REGEX saat ini adalah: foo
INPUT saat ini adalah: fooooooooooooooooo
mencari di(): benar
cocok(): salah

replaceFirst dan replaceAll metode

Metode replaceFirst dan replaceAll digunakan untuk mengganti teks yang cocok dengan ekspresi reguler. Perbedaannya adalah replaceFirst menggantikan pertandingan pertama dan replaceAll menggantikan semua pertandingan.

Contoh berikut menjelaskan fungsi ini:

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

RegexMatches kelas publik
{
String statis pribadi REGEX = "anjing";
private static String INPUT = "Anjing itu berkata mengeong." +
"Semua anjing berkata mengeong.";
String statis pribadi REPLACE = "kucing";

public static void main(String[] args) {
Pola p = Pattern.compile(REGEX);
//dapatkan objek pencocokan
Pencocokan m = p.pencocokan(INPUT);
INPUT = m.replaceAll(GANTI);
Sistem.keluar.println(INPUT);
}
}

Hasil kompilasi dan running dari contoh di atas adalah sebagai berikut:

 Kucing bilang mengeong. Semua kucing bilang mengeong.

metode appendReplacement dan appendTail

Kelas Matcher juga menyediakan metode appendReplacement dan appendTail untuk penggantian teks:

Lihatlah contoh berikut untuk menjelaskan fungsi ini:

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

RegexMatches kelas publik
{
String statis pribadi REGEX = "a*b";
String statis pribadi INPUT = "aabfooaabfooabfoob";
String statis pribadi REPLACE = "-";
public static void main(String[] args) {
Pola p = Pattern.compile(REGEX);
// Dapatkan objek matcher Matcher m = p.matcher(INPUT);
StringBuffer sb = StringBuffer baru();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
Sistem.keluar.println(sb.toString());
}
}

Hasil kompilasi dan running dari contoh di atas adalah sebagai berikut:

 -foo-foo-foo-

Metode kelas PatternSyntaxException

PatternSyntaxException adalah kelas pengecualian yang tidak dipaksakan yang menunjukkan kesalahan sintaksis dalam pola ekspresi reguler.

Kelas PatternSyntaxException menyediakan metode berikut untuk membantu kita melihat kesalahan apa yang terjadi.